home *** CD-ROM | disk | FTP | other *** search
/ Aminet 7 / Aminet 7 - August 1995.iso / Aminet / gfx / 3d / povray_wb3beta.lzh / source.lzh / parse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-30  |  82.1 KB  |  3,244 lines
  1. /****************************************************************************
  2. *                parse.c
  3. *
  4. *  This module implements a parser for the scene description files.
  5. *
  6. *  from Persistence of Vision Raytracer
  7. *  Copyright 1993 Persistence of Vision Team
  8. *---------------------------------------------------------------------------
  9. *  NOTICE: This source code file is provided so that users may experiment
  10. *  with enhancements to POV-Ray and to port the software to platforms other 
  11. *  than those supported by the POV-Ray Team.  There are strict rules under
  12. *  which you are permitted to use this file.  The rules are in the file
  13. *  named POVLEGAL.DOC which should be distributed with this file. If 
  14. *  POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  15. *  Team Coordinator by leaving a message in CompuServe's Graphics Developer's
  16. *  Forum.  The latest version of POV-Ray may be found there as well.
  17. *
  18. * This program is based on the popular DKB raytracer version 2.12.
  19. * DKBTrace was originally written by David K. Buck.
  20. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  21. *
  22. *****************************************************************************/
  23.  
  24. #include "frame.h"
  25. #include "vector.h"
  26. #include "povproto.h"
  27. #include "parse.h"
  28.  
  29. /* This file implements a simple recursive-descent parser for reading the
  30. input file.  */
  31.  
  32. extern DBL Max_Trace_Level;
  33. extern char VerboseFormat;
  34. extern unsigned int Options;
  35. extern int Use_Slabs;
  36. extern char Stat_File_Name[FILE_NAME_LENGTH];
  37.  
  38. extern struct Reserved_Word_Struct Reserved_Words [];
  39. extern DBL Antialias_Threshold;
  40.  
  41. extern struct Token_Struct Token;
  42. extern char String[MAX_STRING_INDEX];
  43.  
  44. extern COLOUR_MAP_ENTRY *Build_Entries;
  45. extern FRAME Frame;
  46. extern DBL Clock_Value;
  47. extern char **Symbol_Table;
  48. extern int Max_Intersections;
  49. extern DBL Language_Version;
  50. extern METHODS Csg_Height_Field_Methods;
  51. extern METHODS CSG_Union_Methods;
  52.  
  53. static void Parse_Image_Map PARAMS((PIGMENT *Pigment));
  54. static void Parse_Bump_Map PARAMS((TNORMAL *Tnormal));
  55. static void Parse_Pigment PARAMS((PIGMENT **Pigment_Ptr));
  56. static void Parse_Tnormal PARAMS((TNORMAL **Tnormal_Ptr));
  57. static void Parse_Finish PARAMS((FINISH **Finish_Ptr));
  58. static TEXTURE *Parse_Texture PARAMS((void));
  59. static void Token_Init PARAMS((void));
  60. static void Frame_Init PARAMS((void));
  61. static void Parse_Coeffs PARAMS((int order, DBL *Coeffs));
  62. static IMAGE *Parse_Image PARAMS((int Legal));
  63. static TRANSFORM *Parse_Transform PARAMS((void));
  64. static void Parse_Object_Mods PARAMS((OBJECT *Object));
  65. static OBJECT *Parse_Bicubic_Patch PARAMS((void));
  66. static OBJECT *Parse_Blob PARAMS((void));
  67. static OBJECT *Parse_Box PARAMS((void));
  68. static OBJECT *Parse_Cone PARAMS((void));
  69. static OBJECT *Parse_Cylinder PARAMS((void));
  70. static OBJECT *Parse_Disc PARAMS((void));
  71. static OBJECT *Parse_Height_Field PARAMS((void));
  72. static OBJECT *Parse_Plane PARAMS((void));
  73. static OBJECT *Parse_Poly PARAMS((int order));
  74. static OBJECT *Parse_Quadric PARAMS((void));
  75. static OBJECT *Parse_Smooth_Triangle PARAMS((void));
  76. static OBJECT *Parse_Sphere PARAMS((void));
  77. static OBJECT *Parse_Torus PARAMS((void));
  78. static OBJECT *Parse_Triangle PARAMS((void));
  79. static OBJECT *Parse_CSG PARAMS((int CSG_Type));
  80. static OBJECT *Parse_Light_Source PARAMS((void));
  81. static OBJECT *Parse_Object PARAMS((void));
  82. static void Parse_Fog PARAMS((void));
  83. static void Parse_Frame PARAMS((void));
  84. static void Parse_Camera PARAMS((CAMERA **Camera_Ptr));
  85. static void Parse_Declare PARAMS((void));
  86. static void Link PARAMS((OBJECT *New_Object,OBJECT **Field,OBJECT **Old_Object_List));
  87. static void Link_Textures PARAMS((TEXTURE **Old_Texture, TEXTURE *New_Texture));
  88. static char *Get_Token_String PARAMS((TOKEN Token_Id));
  89. static void Where_Error PARAMS((void));
  90. static int Test_Redefine PARAMS((int a));
  91. static OBJECT *Parse_Bound_Clip PARAMS((void));
  92. static void Found_Instead PARAMS((void));
  93. /*static void Parse_Warn PARAMS((TOKEN Token_Id));*/
  94. static void Warn_State PARAMS((TOKEN Token_Id, TOKEN Type));
  95. static void Post_Process PARAMS((OBJECT *Object, OBJECT *Parent));
  96. static void Destroy_Constants PARAMS((void));
  97. static OBJECT *Parse_Object_Id PARAMS((void));
  98. static void Link_To_Frame PARAMS((OBJECT *Object));
  99.  
  100. extern struct Constant_Struct Constants[MAX_CONSTANTS];
  101.  
  102. int Number_Of_Constants;
  103. int Previous;
  104. short Have_Vector;
  105. short Not_In_Default;
  106.  
  107. TOKEN *Brace_Stack;
  108. int Brace_Index;
  109.  
  110. TEXTURE *Default_Texture;
  111. CAMERA *Default_Camera;
  112.  
  113. /* Parse the file. */
  114. void Parse ()
  115.   {
  116.    Build_Entries  = NULL;
  117.    if ((Brace_Stack = (TOKEN *) malloc(MAX_BRACES*sizeof (TOKEN))) == NULL)
  118.      MAError ("brace stack");
  119.    Brace_Index = 0;
  120.    Token_Init ();
  121.    Default_Camera = Create_Camera();
  122.    Default_Texture = Create_PNF_Texture();
  123.    Default_Texture->Pigment = Create_Pigment();
  124.    Default_Texture->Tnormal = NULL;
  125.    Default_Texture->Finish  = Create_Finish();
  126.    Not_In_Default = TRUE;
  127.    Frame_Init ();
  128.    Parse_Frame ();
  129.    if (Frame.Objects==NULL)
  130.      Error("No objects in scene");
  131.    Destroy_Constants ();
  132.    Destroy_Textures(Default_Texture);
  133.    Destroy_Camera(Default_Camera);
  134.    if (Build_Entries != NULL)
  135.      free (Build_Entries);
  136.    free (Brace_Stack);
  137.   }
  138.  
  139. static void Token_Init ()
  140.   {
  141.    Number_Of_Constants = 0;
  142.   }
  143.  
  144. /* Set up the fields in the frame to default values. */
  145. static
  146. void Frame_Init ()
  147.   {
  148.    Frame.Camera = Copy_Camera(Default_Camera);
  149.    Frame.Light_Sources = NULL;
  150.    Frame.Objects = NULL;
  151.    Frame.Atmosphere_IOR = 1.0;
  152.    Frame.Antialias_Threshold = Antialias_Threshold;
  153.    Frame.Fog_Distance = 0.0;
  154.    Make_Colour (&(Frame.Fog_Colour), 0.0, 0.0, 0.0);
  155.   }
  156.  
  157. void Parse_Begin ()
  158.   {
  159.    char *front;
  160.  
  161.    Brace_Stack[++Brace_Index]=Token.Token_Id;
  162.    Get_Token ();
  163.  
  164.    if (Token.Token_Id == LEFT_CURLY_TOKEN)
  165.      return;
  166.  
  167.    Where_Error ();
  168.  
  169.    front = Get_Token_String (Brace_Stack[Brace_Index]);
  170.    fprintf (stderr, "Missing { after %s, ", front);
  171.    Found_Instead ();
  172.    exit (1);
  173.   }
  174.  
  175. void Parse_End (void)
  176.   {
  177.    char *front;
  178.  
  179.    Get_Token ();
  180.  
  181.    if (Token.Token_Id == RIGHT_CURLY_TOKEN)
  182.      {
  183.       Brace_Index--;
  184.       return;
  185.      }
  186.  
  187.    Where_Error ();
  188.  
  189.    front = Get_Token_String (Brace_Stack[Brace_Index]);
  190.    fprintf (stderr, "No matching } in %s,", front);
  191.    Found_Instead ();
  192.    exit (1);
  193.   }
  194.  
  195. static OBJECT *Parse_Object_Id (void)
  196.   {
  197.    OBJECT *Object;
  198.    
  199.    EXPECT
  200.      CASE (OBJECT_ID_TOKEN)
  201.        Warn_State(OBJECT_ID_TOKEN, OBJECT_TOKEN);
  202.        Object = Copy_Object((OBJECT *) Token.Constant_Data);
  203.        Parse_Object_Mods (Object);
  204.        EXIT
  205.      END_CASE
  206.  
  207.      OTHERWISE
  208.        Object = NULL;
  209.        UNGET
  210.        EXIT
  211.      END_CASE
  212.    END_EXPECT
  213.  
  214.    return (Object);
  215.   }
  216.  
  217. void Parse_Comma ()
  218.   {
  219.    Get_Token();
  220.    if (Token.Token_Id != COMMA_TOKEN)
  221.      {
  222.       UNGET;
  223.      }
  224.   }
  225.  
  226. static void Parse_Coeffs(order, Coeffs)
  227.   int order;
  228.   DBL *Coeffs;
  229.   {
  230.    int i;
  231.  
  232.    EXPECT
  233.      CASE (LEFT_ANGLE_TOKEN)
  234.        Coeffs[0] = Parse_Float();
  235.        for (i = 1; i < term_counts(order); i++)
  236.          {
  237.           Parse_Comma();
  238.           Coeffs[i] = Parse_Float();
  239.          }
  240.        GET (RIGHT_ANGLE_TOKEN);
  241.        EXIT
  242.      END_CASE
  243.  
  244.      OTHERWISE
  245.        Parse_Error (LEFT_ANGLE_TOKEN);
  246.      END_CASE
  247.    END_EXPECT
  248.   }
  249.  
  250. static
  251. IMAGE *Parse_Image (Legal)
  252.   int Legal;
  253.   {
  254.    IMAGE *Image;
  255.    VECTOR Local_Vector;
  256.  
  257.    Image = Create_Image ();
  258.  
  259.    if (Legal & GRAD_FILE)
  260.      {
  261.       EXPECT
  262.         CASE_VECTOR
  263.           Warn("Should use map_type keyword and/or eliminate orientation.",1.5);
  264.           Have_Vector = FALSE;
  265.           Parse_Vector_Float (&Local_Vector);
  266.           if (Have_Vector)
  267.             Image->Gradient = Local_Vector;
  268.           else
  269.             Image->Map_Type = (int)Local_Vector.x;
  270.         END_CASE
  271.  
  272.         OTHERWISE
  273.           UNGET
  274.           EXIT
  275.         END_CASE
  276.       END_EXPECT
  277.      }
  278.  
  279.    EXPECT
  280.      CASE (IFF_TOKEN)
  281.        Image->File_Type = IFF_FILE;
  282.        GET (STRING_TOKEN);
  283.        Read_Iff_Image (Image, Token.Token_String);
  284.        EXIT
  285.      END_CASE
  286.  
  287.      CASE (GIF_TOKEN)
  288.        Image->File_Type = GIF_FILE;
  289.        GET (STRING_TOKEN);
  290.        Read_Gif_Image(Image, Token.Token_String);
  291.        EXIT
  292.      END_CASE
  293.  
  294.      CASE (POT_TOKEN)
  295.        Image->File_Type = POT_FILE;
  296.        GET (STRING_TOKEN);
  297.        Read_Gif_Image(Image, Token.Token_String);
  298.        EXIT
  299.      END_CASE
  300.  
  301.      CASE (DUMP_TOKEN)
  302.        Image->File_Type = DUMP_FILE;
  303.        GET (STRING_TOKEN);
  304.        Read_Dump_Image(Image, Token.Token_String);
  305.        EXIT
  306.      END_CASE
  307.  
  308.      CASE (TGA_TOKEN)
  309.        Image->File_Type = TGA_FILE;
  310.        GET (STRING_TOKEN);
  311.        Read_Targa_Image(Image, Token.Token_String);
  312.        EXIT
  313.      END_CASE
  314.  
  315.      CASE (PBM_TOKEN)
  316.        Image->File_Type = PBM_FILE;
  317.        GET (STRING_TOKEN);
  318.        Read_PBM_Image(Image, Token.Token_String);
  319.        EXIT
  320.      END_CASE
  321.  
  322.      OTHERWISE
  323.        Parse_Error_Str ("map file spec");
  324.      END_CASE
  325.    END_EXPECT
  326.  
  327.    if (!(Image->File_Type & Legal))
  328.      Error ("File type not supported here");
  329.    return (Image);
  330.   }
  331.  
  332. static void Parse_Image_Map (Pigment)
  333.   PIGMENT *Pigment;
  334.   {
  335.    int reg;
  336.  
  337.    Pigment->Type = IMAGE_MAP_PIGMENT;
  338.  
  339.    Parse_Begin ();
  340.  
  341.    Pigment->Image = Parse_Image (IMAGE_FILE);
  342.    Pigment->Image->Use_Colour_Flag = TRUE;
  343.  
  344.    EXPECT                   /* Look for image_attribs */
  345.      CASE (ONCE_TOKEN)
  346.        Pigment->Image->Once_Flag=TRUE;
  347.      END_CASE
  348.  
  349.      CASE (INTERPOLATE_TOKEN)
  350.        Pigment->Image->Interpolation_Type = (int)Parse_Float();
  351.      END_CASE
  352.  
  353.      CASE (MAP_TYPE_TOKEN)
  354.        Pigment->Image->Map_Type = (int) Parse_Float ();
  355.      END_CASE
  356.  
  357.      CASE (USE_COLOUR_TOKEN)
  358.        Pigment->Image->Use_Colour_Flag = TRUE;
  359.      END_CASE
  360.  
  361.      CASE (USE_INDEX_TOKEN)
  362.        Pigment->Image->Use_Colour_Flag = FALSE;
  363.      END_CASE
  364.  
  365.      CASE (ALPHA_TOKEN)
  366.        Warn("Keyword ALPHA discontinued.  Use FILTER instead.",1.55);
  367.          
  368.      CASE (FILTER_TOKEN)
  369.        EXPECT
  370.          CASE (ALL_TOKEN)
  371.            {
  372.             DBL filter;
  373.             filter = Parse_Float();
  374.             for (reg = 0 ; reg < Pigment->Image->Colour_Map_Size ; reg++)
  375.               Pigment->Image->Colour_Map[reg].Filter
  376.                   = (unsigned short) (filter *255.0);
  377.            }
  378.            EXIT
  379.          END_CASE
  380.  
  381.          OTHERWISE
  382.            UNGET
  383.            reg = (int)(Parse_Float() + 0.01);
  384.            if (Pigment->Image->Colour_Map == NULL)
  385.              Error ("Can't apply FILTER to a non colour-mapped image\n");
  386.            if ((reg < 0) || (reg >= Pigment->Image->Colour_Map_Size))
  387.              Error ("FILTER colour register value out of range.\n");
  388.  
  389.            Parse_Comma();
  390.            Pigment->Image->Colour_Map[reg].Filter
  391.                   = (unsigned short) (255.0 * Parse_Float());
  392.            EXIT
  393.          END_CASE
  394.  
  395.        END_EXPECT
  396.      END_CASE
  397.  
  398.      OTHERWISE
  399.        UNGET
  400.        EXIT
  401.      END_CASE
  402.    END_EXPECT
  403.  
  404.    Parse_End ();
  405. }
  406.  
  407. static void Parse_Bump_Map (Tnormal)
  408.   TNORMAL *Tnormal;
  409.   {
  410.    Tnormal->Type = BUMP_MAP;
  411.  
  412.    Parse_Begin ();
  413.  
  414.    Tnormal->Image = Parse_Image (NORMAL_FILE);
  415.  
  416.    Tnormal->Image->Use_Colour_Flag = TRUE;
  417.  
  418.    EXPECT
  419.      CASE (ONCE_TOKEN)
  420.        Tnormal->Image->Once_Flag=TRUE;
  421.      END_CASE
  422.  
  423.      CASE (MAP_TYPE_TOKEN)
  424.        Tnormal->Image->Map_Type = (int) Parse_Float ();
  425.      END_CASE
  426.  
  427.      CASE (INTERPOLATE_TOKEN)
  428.        Tnormal->Image->Interpolation_Type = (int)Parse_Float();
  429.      END_CASE
  430.  
  431.      CASE (BUMP_SIZE_TOKEN)
  432.        Tnormal->Amount = Parse_Float ();
  433.      END_CASE
  434.  
  435.      CASE (USE_COLOUR_TOKEN)
  436.        Tnormal->Image->Use_Colour_Flag = TRUE;
  437.      END_CASE
  438.  
  439.      CASE (USE_INDEX_TOKEN)
  440.        Tnormal->Image->Use_Colour_Flag = FALSE;
  441.      END_CASE
  442.  
  443.      OTHERWISE
  444.        UNGET
  445.        EXIT
  446.      END_CASE
  447.    END_EXPECT
  448.    Parse_End ();
  449. }
  450.  
  451. static void Parse_Pigment (Pigment_Ptr)
  452.   PIGMENT **Pigment_Ptr;
  453.   {
  454.    PIGMENT *New;
  455.    VECTOR Local_Vector;
  456.  
  457.    Parse_Begin ();
  458.  
  459.    EXPECT            /* Look for [pigment_id] */
  460.      CASE (PIGMENT_ID_TOKEN)
  461.        Destroy_Pigment(*Pigment_Ptr);
  462.        *Pigment_Ptr = Copy_Pigment ((PIGMENT *) Token.Constant_Data);
  463.        EXIT
  464.      END_CASE
  465.  
  466.      OTHERWISE
  467.        UNGET
  468.        EXIT
  469.      END_CASE
  470.    END_EXPECT    /* End pigment_id */
  471.  
  472.    New = *Pigment_Ptr;
  473.  
  474.    EXPECT
  475.      CASE (AGATE_TOKEN)
  476.        New->Type = AGATE_PIGMENT;
  477.        EXIT
  478.      END_CASE
  479.  
  480.      CASE (BOZO_TOKEN)
  481.        New->Type = BOZO_PIGMENT;
  482.        EXIT
  483.      END_CASE
  484.  
  485.      CASE (GRANITE_TOKEN)
  486.        New->Type = GRANITE_PIGMENT;
  487.        EXIT
  488.      END_CASE
  489.  
  490.      CASE (LEOPARD_TOKEN)
  491.        New->Type = LEOPARD_PIGMENT;
  492.        EXIT
  493.      END_CASE
  494.  
  495.      CASE (MARBLE_TOKEN)
  496.        New->Type = MARBLE_PIGMENT;
  497.        EXIT
  498.      END_CASE
  499.  
  500.      CASE (MANDEL_TOKEN)
  501.        New->Type = MANDEL_PIGMENT;
  502.        New->Iterations = (int)Parse_Float();
  503.        EXIT
  504.      END_CASE
  505.  
  506.      CASE (ONION_TOKEN)
  507.        New->Type = ONION_PIGMENT;
  508.        EXIT
  509.      END_CASE
  510.  
  511.      CASE (PAINTED1_TOKEN)
  512.        New->Type = PAINTED1_PIGMENT;
  513.        EXIT
  514.      END_CASE
  515.  
  516.      CASE (PAINTED2_TOKEN)
  517.        New->Type = PAINTED2_PIGMENT;
  518.        EXIT
  519.      END_CASE
  520.  
  521.      CASE (PAINTED3_TOKEN)
  522.        New->Type = PAINTED2_PIGMENT;
  523.        EXIT
  524.      END_CASE
  525.  
  526.      CASE (SPOTTED_TOKEN)
  527.        New->Type = SPOTTED_PIGMENT;
  528.        EXIT
  529.      END_CASE
  530.  
  531.      CASE (WOOD_TOKEN)
  532.        New->Type = WOOD_PIGMENT;
  533.        EXIT
  534.      END_CASE
  535.  
  536.      CASE (GRADIENT_TOKEN)
  537.        New->Type = GRADIENT_PIGMENT;
  538.        Parse_Vector (&(New->Colour_Gradient));
  539.        EXIT
  540.      END_CASE
  541.  
  542.      CASE (RADIAL_TOKEN)
  543.        New->Type = RADIAL_PIGMENT;
  544.      END_CASE
  545.  
  546.      CASE (COLOUR_TOKEN)
  547.        New->Type = COLOUR_PIGMENT;
  548.        New->Colour1 = Create_Colour ();
  549.        Parse_Colour (New->Colour1);
  550.        New->Quick_Colour = *New->Colour1;
  551.        EXIT
  552.      END_CASE
  553.  
  554.      CASE5 (COLOUR_ID_TOKEN, RGB_TOKEN, RGBF_TOKEN, RED_TOKEN, BLUE_TOKEN)
  555.      CASE3 (GREEN_TOKEN, ALPHA_TOKEN, FILTER_TOKEN)
  556.        UNGET
  557.        New->Type = COLOUR_PIGMENT;
  558.        New->Colour1 = Create_Colour ();
  559.        Parse_Colour (New->Colour1);
  560.        New->Quick_Colour = *New->Colour1;
  561.        EXIT
  562.      END_CASE
  563.  
  564.      CASE (CHECKER_TOKEN)
  565.        New->Type = CHECKER_PIGMENT;
  566.        New->Colour_Map = Parse_Colour_List(2);
  567.        EXIT
  568.      END_CASE
  569.  
  570.      CASE (HEXAGON_TOKEN)
  571.        New->Type = HEXAGON_PIGMENT;
  572.        New->Colour_Map = Parse_Colour_List(3);
  573.        EXIT
  574.      END_CASE
  575.  
  576.      CASE (IMAGE_MAP_TOKEN)
  577.        Parse_Image_Map (New);
  578.        EXIT
  579.      END_CASE
  580.  
  581.      OTHERWISE
  582.        UNGET
  583.        EXIT
  584.      END_CASE
  585.    END_EXPECT     /* Concludes pigment_body */
  586.  
  587.    EXPECT         /* Look for pigment_modifier */
  588.      CASE (TURBULENCE_TOKEN)
  589.        Parse_Vector_Float(&(New->Turbulence));
  590.        if ((New->Turbulence.x !=0.0) || (New->Turbulence.y !=0.0) ||
  591.            (New->Turbulence.z !=0.0))
  592.           New->Flags |= HAS_TURB;
  593.      END_CASE
  594.  
  595.      CASE (COLOUR_MAP_TOKEN)
  596.        if (New->Type == CHECKER_PIGMENT ||
  597.            New->Type == HEXAGON_PIGMENT ||
  598.            New->Type == COLOUR_PIGMENT ||
  599.            New->Type == IMAGE_MAP_PIGMENT)
  600.          Warn ("Cannot use color map with this pigment type",1.5);
  601.        New->Colour_Map = Parse_Colour_Map ();
  602.      END_CASE
  603.  
  604.      CASE (QUICK_COLOUR_TOKEN)
  605.        Parse_Colour (&New->Quick_Colour);
  606.      END_CASE
  607.  
  608.      CASE (OCTAVES_TOKEN)
  609.        New->Octaves = (int)Parse_Float();
  610.          if(New->Octaves < 1)
  611.             New->Octaves = 1;
  612.          if(New->Octaves > 10)  /* Avoid DOMAIN errors */
  613.             New->Octaves = 10;
  614.      END_CASE
  615.  
  616.      CASE (OMEGA_TOKEN)
  617.        New->omega = Parse_Float();
  618.      END_CASE
  619.  
  620.      CASE (LAMBDA_TOKEN)
  621.        New->lambda = Parse_Float();
  622.      END_CASE
  623.  
  624.      CASE (FREQUENCY_TOKEN)
  625.        New->Frequency = Parse_Float();
  626.      END_CASE
  627.  
  628.      CASE (PHASE_TOKEN)
  629.        New->Phase = Parse_Float();
  630.      END_CASE
  631.  
  632.      CASE (AGATE_TURB_TOKEN)
  633.        if (Not_In_Default && (New->Type != AGATE_PIGMENT))
  634.           Warn("Attempt to use agate_turb on non-agate",1.9);
  635.        New->Agate_Turb_Scale = Parse_Float();
  636.      END_CASE
  637.  
  638.      CASE (TRANSLATE_TOKEN)
  639.        Parse_Vector (&Local_Vector);
  640.        Translate_Pigment (New, &Local_Vector);
  641.      END_CASE
  642.  
  643.      CASE (ROTATE_TOKEN)
  644.        Parse_Vector (&Local_Vector);
  645.        Rotate_Pigment (New, &Local_Vector);
  646.      END_CASE
  647.  
  648.      CASE (SCALE_TOKEN)
  649.        Parse_Scale_Vector (&Local_Vector);
  650.        Scale_Pigment (New, &Local_Vector);
  651.      END_CASE
  652.  
  653.      CASE (TRANSFORM_TOKEN)
  654.        GET(TRANSFORM_ID_TOKEN)
  655.        Transform_Pigment (New, (TRANSFORM *)Token.Constant_Data);
  656.      END_CASE
  657.  
  658.      OTHERWISE
  659.        UNGET
  660.        EXIT
  661.      END_CASE
  662.    END_EXPECT
  663.  
  664.    if (Not_In_Default && (New->Type == NO_PIGMENT))
  665.      Warn("Pigment type unspecified or not 1st item",1.7);
  666.  
  667.    Parse_End ();
  668.   }
  669.  
  670. static void Parse_Tnormal (Tnormal_Ptr)
  671.   TNORMAL **Tnormal_Ptr;
  672.   {
  673.    TNORMAL *New;
  674.    VECTOR Local_Vector;
  675.  
  676.    Parse_Begin ();
  677.  
  678.    EXPECT            /* Look for [tnormal_id] */
  679.      CASE (TNORMAL_ID_TOKEN)
  680.        Destroy_Tnormal(*Tnormal_Ptr);
  681.        *Tnormal_Ptr = Copy_Tnormal ((TNORMAL *) Token.Constant_Data);
  682.        EXIT
  683.      END_CASE
  684.  
  685.      OTHERWISE
  686.        UNGET
  687.        EXIT
  688.      END_CASE
  689.    END_EXPECT    /* End [tnormal_id] */
  690.  
  691.    if (*Tnormal_Ptr == NULL)
  692.      if ((Default_Texture->Tnormal) != NULL)
  693.        *Tnormal_Ptr = Copy_Tnormal ((Default_Texture->Tnormal));
  694.      else
  695.        *Tnormal_Ptr = Create_Tnormal ();
  696.  
  697.    New = *Tnormal_Ptr;
  698.  
  699.    EXPECT  /* [tnormal_body] */
  700.      CASE (BUMPS_TOKEN)
  701.        New->Type = BUMPS;
  702.        New->Amount = Parse_Float ();
  703.        EXIT
  704.      END_CASE
  705.  
  706.      CASE (BUMPY1_TOKEN)
  707.        New->Type = BUMPY1;
  708.        New->Amount = Parse_Float ();
  709.        EXIT
  710.      END_CASE
  711.  
  712.      CASE (BUMPY2_TOKEN)
  713.        New->Type = BUMPY2;
  714.        New->Amount = Parse_Float ();
  715.        EXIT
  716.      END_CASE
  717.  
  718.      CASE (BUMPY3_TOKEN)
  719.        New->Type = BUMPY3;
  720.        New->Amount = Parse_Float ();
  721.        EXIT
  722.      END_CASE
  723.  
  724.      CASE (DENTS_TOKEN)
  725.        New->Type = DENTS;
  726.        New->Amount = Parse_Float ();
  727.        EXIT
  728.      END_CASE
  729.  
  730.      CASE (RIPPLES_TOKEN)
  731.        New->Type = RIPPLES;
  732.        New->Amount = Parse_Float ();
  733.        EXIT
  734.      END_CASE
  735.  
  736.      CASE (WAVES_TOKEN)
  737.        New->Type = WAVES;
  738.        New->Amount = Parse_Float ();
  739.        EXIT
  740.      END_CASE
  741.  
  742.      CASE (WRINKLES_TOKEN)
  743.        New->Type = WRINKLES;
  744.        New->Amount = Parse_Float ();
  745.        EXIT
  746.      END_CASE
  747.  
  748.      CASE (BUMP_MAP_TOKEN)
  749.        Parse_Bump_Map (New);
  750.        EXIT
  751.      END_CASE
  752.  
  753.      OTHERWISE
  754.        if (Not_In_Default && (New->Type == NO_NORMAL))
  755.          Parse_Error_Str("normal body");
  756.        UNGET
  757.        EXIT
  758.      END_CASE
  759.    END_EXPECT    /* End of tnormal_body */
  760.  
  761.    EXPECT        /* Look for tnormal_mods */
  762.  
  763.      CASE (TURBULENCE_TOKEN)
  764.        Parse_Vector_Float(&(New->Turbulence));
  765.        if ((New->Turbulence.x !=0.0) || (New->Turbulence.y !=0.0) ||
  766.            (New->Turbulence.z !=0.0))
  767.           New->Flags |= HAS_TURB;
  768.      END_CASE
  769.  
  770.      CASE (OCTAVES_TOKEN)
  771.        New->Octaves = (int)Parse_Float();
  772.      END_CASE
  773.  
  774.      CASE (OMEGA_TOKEN)
  775.        New->omega = Parse_Float();
  776.      END_CASE
  777.  
  778.      CASE (LAMBDA_TOKEN)
  779.        New->lambda = Parse_Float();
  780.      END_CASE
  781.  
  782.      CASE (FREQUENCY_TOKEN)
  783.        if (!(New->Type == RIPPLES || New->Type == WAVES))
  784.          if (Language_Version >= 1.5)
  785.            Warn ("Cannot use frequency with this normal",1.5);
  786.        New->Frequency = Parse_Float();
  787.      END_CASE
  788.  
  789.      CASE (PHASE_TOKEN)
  790.        if (!(New->Type == RIPPLES || New->Type == WAVES))
  791.          if (Language_Version >= 1.5)
  792.             Warn ("Cannot use phase with this normal",1.5);
  793.        New->Phase = Parse_Float();
  794.      END_CASE
  795.  
  796.      CASE (TRANSLATE_TOKEN)
  797.        Parse_Vector (&Local_Vector);
  798.        Translate_Tnormal (New, &Local_Vector);
  799.      END_CASE
  800.  
  801.      CASE (ROTATE_TOKEN)
  802.        Parse_Vector (&Local_Vector);
  803.        Rotate_Tnormal (New, &Local_Vector);
  804.      END_CASE
  805.  
  806.      CASE (SCALE_TOKEN)
  807.        Parse_Scale_Vector (&Local_Vector);
  808.        Scale_Tnormal (New, &Local_Vector);
  809.      END_CASE
  810.  
  811.      CASE (TRANSFORM_TOKEN)
  812.        GET(TRANSFORM_ID_TOKEN)
  813.        Transform_Tnormal (New, (TRANSFORM *)Token.Constant_Data);
  814.      END_CASE
  815.  
  816.      OTHERWISE
  817.        UNGET
  818.        EXIT
  819.      END_CASE
  820.    END_EXPECT    /* End of tnormal_mods */
  821.  
  822.    Parse_End ();
  823.   }
  824.  
  825. static void Parse_Finish (Finish_Ptr)
  826.   FINISH **Finish_Ptr;
  827.   {
  828.    FINISH *New;
  829.  
  830.    Parse_Begin ();
  831.  
  832.    EXPECT        /* Look for zero or one finish_id */
  833.      CASE (FINISH_ID_TOKEN)
  834.        Destroy_Finish(*Finish_Ptr);
  835.        *Finish_Ptr = Copy_Finish ((FINISH *) Token.Constant_Data);
  836.        EXIT
  837.      END_CASE
  838.  
  839.      OTHERWISE
  840.        UNGET
  841.        EXIT
  842.      END_CASE
  843.    END_EXPECT    /* End finish_id */
  844.  
  845.    New = *Finish_Ptr;
  846.  
  847.    EXPECT        /* Look for zero or more finish_body */
  848.      CASE (AMBIENT_TOKEN)
  849.        New->Ambient = Parse_Float ();
  850.      END_CASE
  851.  
  852.      CASE (BRILLIANCE_TOKEN)
  853.        New->Brilliance = Parse_Float ();
  854.      END_CASE
  855.  
  856.      CASE (DIFFUSE_TOKEN)
  857.        New->Diffuse = Parse_Float ();
  858.      END_CASE
  859.  
  860.      CASE (REFLECTION_TOKEN)
  861.        New->Reflection = Parse_Float ();
  862.      END_CASE
  863.  
  864.      CASE (REFRACTION_TOKEN)
  865.        New->Refraction = Parse_Float ();
  866.      END_CASE
  867.  
  868.      CASE (IOR_TOKEN)
  869.        New->Index_Of_Refraction = Parse_Float ();
  870.      END_CASE
  871.  
  872.      CASE (PHONG_TOKEN)
  873.        New->Phong = Parse_Float ();
  874.      END_CASE
  875.  
  876.      CASE (PHONG_SIZE_TOKEN)
  877.        New->Phong_Size = Parse_Float ();
  878. /*     if (New->Phong_Size < 1.0)
  879.            New->Phong_Size = 1.0;
  880.        if (New->Phong_Size > 100)
  881.            New->Phong_Size = 100; */
  882.      END_CASE
  883.  
  884.      CASE (SPECULAR_TOKEN)
  885.        New->Specular = Parse_Float ();
  886.      END_CASE
  887.  
  888.      CASE (ROUGHNESS_TOKEN)
  889.        New->Roughness = Parse_Float ();
  890. /*     if (New->Roughness > 1.0)
  891.            New->Roughness = 1.0;
  892.        if (New->Roughness < 0.001)
  893.            New->Roughness = 0.001;  */
  894.        New->Roughness = 1.0/New->Roughness; /* CEY 12/92 */
  895.      END_CASE
  896.  
  897.      CASE (METALLIC_TOKEN)
  898.        New->Metallic_Flag = TRUE;
  899.      END_CASE
  900.  
  901.      CASE (CRAND_TOKEN)
  902.        New->Crand = Parse_Float();
  903.      END_CASE
  904.  
  905.      OTHERWISE
  906.        UNGET
  907.        EXIT
  908.      END_CASE
  909.    END_EXPECT    /* End of finish_body */
  910.  
  911.    EXPECT        /* Look for finish_mods */
  912.  
  913. /*   CASE none implemented
  914.      END_CASE     */
  915.  
  916.      OTHERWISE
  917.        UNGET
  918.        EXIT
  919.      END_CASE
  920.    END_EXPECT    /* End of finish_mods */
  921.  
  922.    Parse_End ();
  923.   }
  924.  
  925. #define ADD_TNORMAL if (Tnormal == NULL) {if ((Default_Texture->Tnormal) != NULL) \
  926.  Tnormal = Copy_Tnormal ((Default_Texture->Tnormal)); else Tnormal = Create_Tnormal ();\
  927.  Texture->Tnormal=Tnormal;};
  928.  
  929. static
  930. TEXTURE *Parse_Texture ()
  931.   {
  932.    VECTOR Local_Vector;
  933.    TEXTURE *Texture, *Local_Texture;
  934.    PIGMENT *Pigment;
  935.    TNORMAL *Tnormal;
  936.    FINISH *Finish;
  937.  
  938.    Parse_Begin ();
  939.  
  940.    EXPECT                      /* Look for texture_body */
  941.      CASE (TILES_TOKEN)
  942.        Parse_Begin ();
  943.  
  944.        Texture = (TEXTURE *)Create_Tiles_Texture ();
  945.  
  946.        EXPECT
  947.          CASE (TEXTURE_TOKEN)
  948.            Local_Texture = Parse_Texture ();
  949.            Link_Textures(&(((TILES *)Texture)->Tile1),Local_Texture);
  950.          END_CASE
  951.  
  952.          OTHERWISE
  953.            UNGET
  954.            EXIT
  955.          END_CASE
  956.        END_EXPECT
  957.  
  958.        GET (TILE2_TOKEN);
  959.  
  960.        EXPECT
  961.          CASE (TEXTURE_TOKEN)
  962.            Local_Texture = Parse_Texture ();
  963.            Link_Textures(&(((TILES *)Texture)->Tile2),Local_Texture);
  964.          END_CASE
  965.  
  966.          OTHERWISE
  967.            UNGET
  968.            EXIT
  969.          END_CASE
  970.        END_EXPECT
  971.        Parse_End ();
  972.        EXIT
  973.      END_CASE
  974.  
  975.      CASE (MATERIAL_MAP_TOKEN)
  976.        Parse_Begin ();
  977.  
  978.        Texture = (TEXTURE *)Create_Material_Texture ();
  979.  
  980.        ((MATERIAL *)Texture)->Image = Parse_Image(MATERIAL_FILE);
  981.        ((MATERIAL *)Texture)->Image->Use_Colour_Flag = FALSE;
  982.  
  983.        EXPECT
  984.          CASE (ONCE_TOKEN)
  985.            ((MATERIAL *)Texture)->Image->Once_Flag=TRUE;
  986.          END_CASE
  987.  
  988.          CASE (INTERPOLATE_TOKEN)
  989.            ((MATERIAL *)Texture)->Image->Interpolation_Type=(int)Parse_Float();
  990.          END_CASE
  991.  
  992.          CASE (MAP_TYPE_TOKEN)
  993.            ((MATERIAL *)Texture)->Image->Map_Type = (int) Parse_Float ();
  994.          END_CASE
  995.  
  996.          OTHERWISE
  997.            UNGET
  998.            EXIT
  999.          END_CASE
  1000.        END_EXPECT
  1001.  
  1002.        GET (TEXTURE_TOKEN)                /* First material */
  1003.        ((MATERIAL *)Texture)->Materials = Local_Texture = Parse_Texture ();
  1004.        ((MATERIAL *)Texture)->Num_Of_Mats++;
  1005.  
  1006.        EXPECT                             /* Subsequent materials */
  1007.          CASE (TEXTURE_TOKEN)
  1008.            Local_Texture->Next_Material = Parse_Texture ();
  1009.            Local_Texture = Local_Texture->Next_Material;
  1010.            ((MATERIAL *)Texture)->Num_Of_Mats++;
  1011.          END_CASE
  1012.  
  1013.          OTHERWISE
  1014.            UNGET
  1015.            EXIT
  1016.          END_CASE
  1017.        END_EXPECT
  1018.        Parse_End ();
  1019.        EXIT
  1020.      END_CASE
  1021.  
  1022.      OTHERWISE  /* Look for [pnf_texture] */
  1023.        UNGET
  1024.  
  1025.        Texture = Copy_Textures (Default_Texture);
  1026.  
  1027.        EXPECT   /* Look for [tpnf_ids] */
  1028.          CASE (TEXTURE_ID_TOKEN)
  1029.            Destroy_Textures(Texture);
  1030.            Texture = Copy_Textures((TEXTURE *) Token.Constant_Data);
  1031.          END_CASE
  1032.  
  1033.          CASE (PIGMENT_ID_TOKEN)
  1034.            Destroy_Pigment(Texture->Pigment);
  1035.            Texture->Pigment = Copy_Pigment ((PIGMENT *) Token.Constant_Data);
  1036.          END_CASE
  1037.  
  1038.          CASE (TNORMAL_ID_TOKEN)
  1039.            Destroy_Tnormal(Texture->Tnormal);
  1040.            Texture->Tnormal = Copy_Tnormal ((TNORMAL *) Token.Constant_Data);
  1041.          END_CASE
  1042.  
  1043.          CASE (FINISH_ID_TOKEN)
  1044.            Destroy_Finish(Texture->Finish);
  1045.            Texture->Finish = Copy_Finish ((FINISH *) Token.Constant_Data);
  1046.          END_CASE
  1047.  
  1048.          OTHERWISE
  1049.            UNGET
  1050.            EXIT
  1051.          END_CASE
  1052.        END_EXPECT
  1053.  
  1054.        Pigment = Texture->Pigment;
  1055.        Tnormal = Texture->Tnormal;
  1056.        Finish  = Texture->Finish;
  1057.  
  1058.        EXPECT
  1059.          CASE (PIGMENT_TOKEN)
  1060.            Parse_Pigment ( &(Texture->Pigment) );
  1061.          END_CASE
  1062.  
  1063.          CASE (TNORMAL_TOKEN)
  1064.            Parse_Tnormal ( &(Texture->Tnormal) );
  1065.          END_CASE
  1066.  
  1067.          CASE (FINISH_TOKEN)
  1068.            Parse_Finish ( &(Texture->Finish) );
  1069.          END_CASE
  1070.  
  1071. /***********************************************************************
  1072.  PIGMENT STUFF OUTSIDE PIGMENT{}
  1073. ***********************************************************************/
  1074.          CASE (AGATE_TOKEN)
  1075.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1076.            Pigment->Type = AGATE_PIGMENT;
  1077.          END_CASE
  1078.  
  1079.          CASE (BOZO_TOKEN)
  1080.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1081.            Pigment->Type = BOZO_PIGMENT;
  1082.          END_CASE
  1083.  
  1084.          CASE (GRANITE_TOKEN)
  1085.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1086.            Pigment->Type = GRANITE_PIGMENT;
  1087.          END_CASE
  1088.  
  1089.          CASE (LEOPARD_TOKEN)
  1090.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1091.            Pigment->Type = LEOPARD_PIGMENT;
  1092.          END_CASE
  1093.  
  1094.          CASE (MARBLE_TOKEN)
  1095.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1096.            Pigment->Type = MARBLE_PIGMENT;
  1097.          END_CASE
  1098.  
  1099.          CASE (MANDEL_TOKEN)
  1100.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1101.            Pigment->Type = MANDEL_PIGMENT;
  1102.            Pigment->Iterations = (int)Parse_Float();
  1103.          END_CASE
  1104.  
  1105.          CASE (ONION_TOKEN)
  1106.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1107.            Pigment->Type = ONION_PIGMENT;
  1108.          END_CASE
  1109.  
  1110.          CASE (PAINTED1_TOKEN)
  1111.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1112.            Pigment->Type = PAINTED1_PIGMENT;
  1113.          END_CASE
  1114.  
  1115.          CASE (PAINTED2_TOKEN)
  1116.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1117.            Pigment->Type = PAINTED2_PIGMENT;
  1118.          END_CASE
  1119.  
  1120.          CASE (PAINTED3_TOKEN)
  1121.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1122.            Pigment->Type = PAINTED2_PIGMENT;
  1123.          END_CASE
  1124.  
  1125.          CASE (SPOTTED_TOKEN)
  1126.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1127.            Pigment->Type = SPOTTED_PIGMENT;
  1128.          END_CASE
  1129.  
  1130.          CASE (WOOD_TOKEN)
  1131.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1132.            Pigment->Type = WOOD_PIGMENT;
  1133.          END_CASE
  1134.  
  1135.          CASE (GRADIENT_TOKEN)
  1136.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1137.            Pigment->Type = GRADIENT_PIGMENT;
  1138.            Parse_Vector (&(Pigment->Colour_Gradient));
  1139.          END_CASE
  1140.  
  1141.          CASE (COLOUR_TOKEN)
  1142.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1143.            Pigment->Type = COLOUR_PIGMENT;
  1144.            Pigment->Colour1 = Create_Colour ();
  1145.            Parse_Colour (Pigment->Colour1);
  1146.            Pigment->Quick_Colour = *Pigment->Colour1;
  1147.          END_CASE
  1148.  
  1149.          CASE5 (COLOUR_ID_TOKEN, RGB_TOKEN, RGBF_TOKEN, RED_TOKEN, BLUE_TOKEN)
  1150.          CASE3 (GREEN_TOKEN, ALPHA_TOKEN, FILTER_TOKEN)
  1151.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1152.            UNGET
  1153.            Pigment->Type = COLOUR_PIGMENT;
  1154.            Pigment->Colour1 = Create_Colour ();
  1155.            Parse_Colour (Pigment->Colour1);
  1156.            Pigment->Quick_Colour = *Pigment->Colour1;
  1157.          END_CASE
  1158.  
  1159.          CASE (CHECKER_TOKEN)
  1160.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1161.            Pigment->Type = CHECKER_PIGMENT;
  1162.            Pigment->Colour_Map = Parse_Colour_List(2);
  1163.          END_CASE
  1164.  
  1165.          CASE (HEXAGON_TOKEN)
  1166.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1167.            Pigment->Type = HEXAGON_PIGMENT;
  1168.            Pigment->Colour_Map = Parse_Colour_List(3);
  1169.          END_CASE
  1170.  
  1171.          CASE (IMAGE_MAP_TOKEN)
  1172.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1173.            Parse_Image_Map (Pigment);
  1174.          END_CASE
  1175.  
  1176.          CASE (TURBULENCE_TOKEN)
  1177.            Parse_Vector_Float(&(Pigment->Turbulence));
  1178.            if ((Pigment->Turbulence.x !=0.0) ||
  1179.                (Pigment->Turbulence.y !=0.0) ||
  1180.                (Pigment->Turbulence.z !=0.0))
  1181.              Pigment->Flags |= HAS_TURB;
  1182.          END_CASE
  1183.  
  1184.          CASE (COLOUR_MAP_TOKEN)
  1185.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);
  1186.            if (Pigment->Type == CHECKER_PIGMENT ||
  1187.                Pigment->Type == HEXAGON_PIGMENT ||
  1188.                Pigment->Type == COLOUR_PIGMENT ||
  1189.                Pigment->Type == IMAGE_MAP_PIGMENT)
  1190.              Warn ("Cannot use color map with this pigment type",1.5);
  1191.            Pigment->Colour_Map = Parse_Colour_Map ();
  1192.          END_CASE
  1193.  
  1194.          CASE (QUICK_COLOUR_TOKEN)
  1195.            Warn_State(Token.Token_Id, PIGMENT_TOKEN);           
  1196.            Parse_Colour (&Pigment->Quick_Colour);
  1197.          END_CASE
  1198.  
  1199.          CASE (OCTAVES_TOKEN)
  1200.            Pigment->Octaves = (int)Parse_Float();
  1201.              if(Pigment->Octaves < 1)
  1202.                 Pigment->Octaves = 1;
  1203.              if(Pigment->Octaves > 10)  /* Avoid DOMAIN errors */
  1204.                 Pigment->Octaves = 10;
  1205.          END_CASE
  1206.  
  1207.          CASE (OMEGA_TOKEN)
  1208.            Pigment->omega = Parse_Float();
  1209.          END_CASE
  1210.  
  1211.          CASE (LAMBDA_TOKEN)
  1212.            Pigment->lambda = Parse_Float();
  1213.          END_CASE
  1214.  
  1215. /***********************************************************************
  1216. TNORMAL STUFF OUTSIDE NORMAL{}
  1217. ***********************************************************************/
  1218.          CASE (BUMPS_TOKEN)
  1219.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1220.            ADD_TNORMAL
  1221.            Tnormal->Type = BUMPS;
  1222.            Tnormal->Amount = Parse_Float ();
  1223.          END_CASE
  1224.  
  1225.          CASE (BUMPY1_TOKEN)
  1226.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1227.            ADD_TNORMAL
  1228.            Tnormal->Type = BUMPY1;
  1229.            Tnormal->Amount = Parse_Float ();
  1230.          END_CASE
  1231.  
  1232.          CASE (BUMPY2_TOKEN)
  1233.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1234.            ADD_TNORMAL
  1235.            Tnormal->Type = BUMPY2;
  1236.            Tnormal->Amount = Parse_Float ();
  1237.          END_CASE
  1238.  
  1239.          CASE (BUMPY3_TOKEN)
  1240.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1241.            ADD_TNORMAL
  1242.            Tnormal->Type = BUMPY3;
  1243.            Tnormal->Amount = Parse_Float ();
  1244.          END_CASE
  1245.  
  1246.          CASE (DENTS_TOKEN)
  1247.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1248.            ADD_TNORMAL
  1249.            Tnormal->Type = DENTS;
  1250.            Tnormal->Amount = Parse_Float ();
  1251.          END_CASE
  1252.  
  1253.          CASE (RIPPLES_TOKEN)
  1254.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1255.            ADD_TNORMAL
  1256.            Tnormal->Type = RIPPLES;
  1257.            Tnormal->Amount = Parse_Float ();
  1258.          END_CASE
  1259.  
  1260.          CASE (WAVES_TOKEN)
  1261.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1262.            ADD_TNORMAL
  1263.            Tnormal->Type = WAVES;
  1264.            Tnormal->Amount = Parse_Float ();
  1265.          END_CASE
  1266.  
  1267.          CASE (WRINKLES_TOKEN)
  1268.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1269.            ADD_TNORMAL
  1270.            Tnormal->Type = WRINKLES;
  1271.            Tnormal->Amount = Parse_Float ();
  1272.          END_CASE
  1273.  
  1274.          CASE (BUMP_MAP_TOKEN)
  1275.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1276.            ADD_TNORMAL
  1277.            Parse_Bump_Map (Tnormal);
  1278.          END_CASE
  1279.  
  1280.          CASE (FREQUENCY_TOKEN)
  1281.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1282.            ADD_TNORMAL
  1283.            if (!(Tnormal->Type == RIPPLES || Tnormal->Type == WAVES))
  1284.              if (Language_Version >= 1.5)
  1285.                Warn ("Cannot use frequency with this normal",1.5);
  1286.            Tnormal->Frequency = Parse_Float();
  1287.          END_CASE
  1288.  
  1289.          CASE (PHASE_TOKEN)
  1290.            Warn_State(Token.Token_Id, TNORMAL_TOKEN);           
  1291.            ADD_TNORMAL
  1292.            if (!(Tnormal->Type == RIPPLES || Tnormal->Type == WAVES))
  1293.              if (Language_Version >= 1.5)
  1294.                Warn ("Cannot use phase with this normal",1.5);
  1295.            Tnormal->Phase = Parse_Float();
  1296.          END_CASE
  1297.  
  1298.  
  1299. /***********************************************************************
  1300. FINISH STUFF OUTSIDE FINISH{}
  1301. ***********************************************************************/
  1302.          CASE (AMBIENT_TOKEN)
  1303.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1304.            Finish->Ambient = Parse_Float ();
  1305.          END_CASE
  1306.  
  1307.          CASE (BRILLIANCE_TOKEN)
  1308.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1309.            Finish->Brilliance = Parse_Float ();
  1310.          END_CASE
  1311.  
  1312.          CASE (DIFFUSE_TOKEN)
  1313.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1314.            Finish->Diffuse = Parse_Float ();
  1315.          END_CASE
  1316.  
  1317.          CASE (REFLECTION_TOKEN)
  1318.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1319.            Finish->Reflection = Parse_Float ();
  1320.          END_CASE
  1321.  
  1322.          CASE (REFRACTION_TOKEN)
  1323.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1324.            Finish->Refraction = Parse_Float ();
  1325.          END_CASE
  1326.  
  1327.          CASE (IOR_TOKEN)
  1328.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1329.            Finish->Index_Of_Refraction = Parse_Float ();
  1330.          END_CASE
  1331.  
  1332.          CASE (PHONG_TOKEN)
  1333.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1334.            Finish->Phong = Parse_Float ();
  1335.          END_CASE
  1336.  
  1337.          CASE (PHONG_SIZE_TOKEN)
  1338.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1339.            Finish->Phong_Size = Parse_Float ();
  1340.     /*     if (Finish->Phong_Size < 1.0)
  1341.                Finish->Phong_Size = 1.0;
  1342.            if (Finish->Phong_Size > 100)
  1343.                Finish->Phong_Size = 100; */
  1344.          END_CASE
  1345.  
  1346.          CASE (SPECULAR_TOKEN)
  1347.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1348.            Finish->Specular = Parse_Float ();
  1349.          END_CASE
  1350.  
  1351.          CASE (ROUGHNESS_TOKEN)
  1352.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1353.            Finish->Roughness = Parse_Float ();
  1354.     /*     if (Finish->Roughness > 1.0)
  1355.                Finish->Roughness = 1.0;
  1356.            if (Finish->Roughness < 0.001)
  1357.                Finish->Roughness = 0.001;  */
  1358.            Finish->Roughness = 1.0/Finish->Roughness; /* CEY 12/92 */
  1359.          END_CASE
  1360.  
  1361.          CASE (METALLIC_TOKEN)
  1362.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1363.            Finish->Metallic_Flag = TRUE;
  1364.          END_CASE
  1365.  
  1366.          CASE (CRAND_TOKEN)
  1367.            Warn_State(Token.Token_Id, FINISH_TOKEN);           
  1368.            Finish->Crand = Parse_Float();
  1369.          END_CASE
  1370.  
  1371.          CASE_FLOAT
  1372.            Finish->Crand = Parse_Float();
  1373.            Warn("Should use crand keyword in finish statement.",1.5);           
  1374.          END_CASE
  1375.  
  1376.          CASE (TRANSLATE_TOKEN)
  1377.            Parse_Vector (&Local_Vector);
  1378.            Translate_Textures (Texture, &Local_Vector);
  1379.          END_CASE
  1380.  
  1381.          CASE (ROTATE_TOKEN)
  1382.            Parse_Vector (&Local_Vector);
  1383.            Rotate_Textures (Texture, &Local_Vector);
  1384.          END_CASE
  1385.  
  1386.          CASE (SCALE_TOKEN)
  1387.            Parse_Scale_Vector (&Local_Vector);
  1388.            Scale_Textures (Texture, &Local_Vector);
  1389.          END_CASE
  1390.  
  1391.          CASE (TRANSFORM_TOKEN)
  1392.            GET(TRANSFORM_ID_TOKEN)
  1393.            Transform_Textures (Texture, (TRANSFORM *)Token.Constant_Data);
  1394.          END_CASE
  1395.  
  1396.          CASE (TEXTURE_ID_TOKEN)
  1397.            Warn("Texture identifier overwriting previous values.",0.);
  1398.            Destroy_Textures(Texture);
  1399.            Texture = Copy_Textures((TEXTURE *) Token.Constant_Data);
  1400.            Pigment = Texture->Pigment;
  1401.            Tnormal = Texture->Tnormal;
  1402.            Finish  = Texture->Finish;
  1403.          END_CASE
  1404.  
  1405.          OTHERWISE
  1406.            UNGET
  1407.            EXIT
  1408.          END_CASE
  1409. /***********************************************************************/
  1410.  
  1411.        END_EXPECT
  1412.  
  1413.        if (Not_In_Default && (Texture->Pigment->Type == NO_PIGMENT) &&
  1414.            !(Language_Version < 1.5))
  1415.          Parse_Error(PIGMENT_ID_TOKEN);
  1416.  
  1417.        EXIT
  1418.      END_CASE        /* End of pnf texture */
  1419.  
  1420.    END_EXPECT       /* End of texture_body */
  1421.  
  1422.    EXPECT            /* Look for texture_mods */
  1423.      CASE (TRANSLATE_TOKEN)
  1424.        Parse_Vector (&Local_Vector);
  1425.        Translate_Textures (Texture, &Local_Vector);
  1426.      END_CASE
  1427.  
  1428.      CASE (ROTATE_TOKEN)
  1429.        Parse_Vector (&Local_Vector);
  1430.        Rotate_Textures (Texture, &Local_Vector);
  1431.      END_CASE
  1432.  
  1433.      CASE (SCALE_TOKEN)
  1434.        Parse_Scale_Vector (&Local_Vector);
  1435.        Scale_Textures (Texture, &Local_Vector);
  1436.      END_CASE
  1437.  
  1438.      CASE (TRANSFORM_TOKEN)
  1439.        GET(TRANSFORM_ID_TOKEN)
  1440.        Transform_Textures (Texture, (TRANSFORM *)Token.Constant_Data);
  1441.      END_CASE
  1442.  
  1443.      OTHERWISE
  1444.        UNGET
  1445.        EXIT
  1446.      END_CASE
  1447.    END_EXPECT        /* End of texture */
  1448.  
  1449.    Parse_End ();
  1450.    return (Texture);
  1451.   }
  1452.  
  1453. static
  1454. OBJECT *Parse_Bound_Clip ()
  1455.   {
  1456.    VECTOR Local_Vector;
  1457.    OBJECT *First, *Current, *Prev;
  1458.  
  1459.    First = Prev = NULL;
  1460.  
  1461.    while ((Current = Parse_Object ()) != NULL)
  1462.      {
  1463.       if (Current->Type & (TEXTURED_OBJECT+PATCH_OBJECT))
  1464.         Error ("Illegal texture or patch in clip or bound");
  1465.       if (First == NULL)
  1466.         First = Current;
  1467.       if (Prev != NULL)
  1468.         Prev->Sibling = Current;
  1469.       Prev = Current;
  1470.      }
  1471.  
  1472.    EXPECT
  1473.      CASE (TRANSLATE_TOKEN)
  1474.        Parse_Vector (&Local_Vector);
  1475.        for (Current = First;
  1476.             Current != NULL;
  1477.             Current = Current->Sibling)
  1478.          Translate_Object (Current, &Local_Vector);
  1479.      END_CASE
  1480.  
  1481.      CASE (ROTATE_TOKEN)
  1482.        Parse_Vector (&Local_Vector);
  1483.        for (Current = First;
  1484.             Current != NULL;
  1485.             Current = Current->Sibling)
  1486.          Rotate_Object (Current, &Local_Vector);
  1487.      END_CASE
  1488.  
  1489.      CASE (SCALE_TOKEN)
  1490.        Parse_Scale_Vector (&Local_Vector);
  1491.        for (Current = First;
  1492.             Current != NULL;
  1493.             Current = Current->Sibling)
  1494.          Scale_Object (Current, &Local_Vector);
  1495.      END_CASE
  1496.  
  1497.      CASE (TRANSFORM_TOKEN)
  1498.        GET(TRANSFORM_ID_TOKEN)
  1499.        for (Current = First;
  1500.             Current != NULL;
  1501.             Current = Current->Sibling)
  1502.        Transform_Object (Current, (TRANSFORM *)Token.Constant_Data);
  1503.      END_CASE
  1504.  
  1505.      OTHERWISE
  1506.        UNGET
  1507.        EXIT
  1508.      END_CASE
  1509.    END_EXPECT
  1510.  
  1511.    return (First);
  1512.   }
  1513.  
  1514. static void Parse_Object_Mods (OBJECT *Object)
  1515. /*
  1516.   OBJECT *Object;
  1517. */
  1518.   {
  1519.    VECTOR Local_Vector;
  1520.    TEXTURE *Local_Texture;
  1521.    COLOUR Local_Colour;
  1522.  
  1523.    EXPECT
  1524.      CASE (COLOUR_TOKEN)
  1525.        Parse_Colour (&Local_Colour);
  1526.        if (Language_Version < 1.5)
  1527.          if (Object->Texture != NULL) 
  1528.            if (Object->Texture->Type == PNF_TEXTURE)
  1529.              {
  1530.               Object->Texture->Pigment->Quick_Colour = Local_Colour;
  1531.               break;  /* acts like END_CASE */
  1532.              }
  1533.        Warn("Quick color belongs in texture.  Color ignored.",0.0);
  1534.      END_CASE
  1535.  
  1536.      CASE (TRANSLATE_TOKEN)
  1537.        Parse_Vector (&Local_Vector);
  1538.        Translate_Object (Object, &Local_Vector);
  1539.      END_CASE
  1540.  
  1541.      CASE (ROTATE_TOKEN)
  1542.        Parse_Vector (&Local_Vector);
  1543.        Rotate_Object (Object, &Local_Vector);
  1544.      END_CASE
  1545.  
  1546.      CASE (SCALE_TOKEN)
  1547.        Parse_Scale_Vector (&Local_Vector);
  1548.        Scale_Object (Object, &Local_Vector);
  1549.      END_CASE
  1550.  
  1551.      CASE (TRANSFORM_TOKEN)
  1552.        GET(TRANSFORM_ID_TOKEN)
  1553.        Transform_Object (Object, (TRANSFORM *)Token.Constant_Data);
  1554.      END_CASE
  1555.  
  1556.      CASE (BOUNDED_BY_TOKEN)
  1557.        Parse_Begin ();
  1558.        if (Object->Bound != NULL)
  1559.          Error ("Cannot have more than one BOUNDED_BY {} per object");
  1560.  
  1561.        EXPECT
  1562.          CASE (CLIPPED_BY_TOKEN)
  1563.            Object->Bound = Object->Clip;
  1564.            EXIT
  1565.          END_CASE
  1566.  
  1567.          OTHERWISE
  1568.            UNGET
  1569.            Object->Bound = Parse_Bound_Clip ();
  1570.            EXIT
  1571.          END_CASE
  1572.        END_EXPECT
  1573.        
  1574.        Parse_End ();
  1575.      END_CASE
  1576.  
  1577.      CASE (CLIPPED_BY_TOKEN)
  1578.        Parse_Begin ();
  1579.        if (Object->Clip != NULL)
  1580.          Error ("Cannot have more than one CLIPPED_BY {} per object");
  1581.  
  1582.        EXPECT
  1583.          CASE (BOUNDED_BY_TOKEN)
  1584.            Object->Clip = Object->Bound;
  1585.            EXIT
  1586.          END_CASE
  1587.  
  1588.          OTHERWISE
  1589.            UNGET
  1590.            Object->Clip = Parse_Bound_Clip ();
  1591.            EXIT
  1592.          END_CASE
  1593.        END_EXPECT
  1594.  
  1595.        Parse_End ();
  1596.      END_CASE
  1597.  
  1598.      CASE (TEXTURE_TOKEN)
  1599.        Object->Type |= TEXTURED_OBJECT;
  1600.        Local_Texture = Parse_Texture ();
  1601.        Link_Textures(&(Object->Texture), Local_Texture);
  1602.      END_CASE
  1603.  
  1604.      CASE3 (PIGMENT_TOKEN, TNORMAL_TOKEN, FINISH_TOKEN)
  1605.        Object->Type |= TEXTURED_OBJECT;
  1606.        if (Object->Texture == NULL)
  1607.          Object->Texture = Copy_Textures(Default_Texture);
  1608.        else
  1609.          if (Object->Texture->Type != PNF_TEXTURE)
  1610.            Link_Textures(&(Object->Texture), Copy_Textures(Default_Texture));
  1611.        UNGET
  1612.        EXPECT
  1613.          CASE (PIGMENT_TOKEN)
  1614.            Parse_Pigment ( &(Object->Texture->Pigment) );
  1615.          END_CASE
  1616.  
  1617.          CASE (TNORMAL_TOKEN)
  1618.            Parse_Tnormal ( &(Object->Texture->Tnormal) );
  1619.          END_CASE
  1620.  
  1621.          CASE (FINISH_TOKEN)
  1622.            Parse_Finish ( &(Object->Texture->Finish) );
  1623.          END_CASE
  1624.  
  1625.          OTHERWISE
  1626.            UNGET
  1627.            EXIT
  1628.          END_CASE
  1629.        END_EXPECT
  1630.      END_CASE
  1631.  
  1632.      CASE (INVERSE_TOKEN)
  1633.        if (Object->Type & PATCH_OBJECT)
  1634.          Warn ("Cannot invert a patch object",0.0);
  1635.        Invert_Object (Object);
  1636.      END_CASE
  1637.  
  1638.      CASE (STURM_TOKEN)
  1639.        if (!(Object->Type & STURM_OK_OBJECT))
  1640.          Error ("Cannot use STRUM here");
  1641.        ((POLY *) Object)->Sturm_Flag = TRUE;
  1642.      END_CASE
  1643.  
  1644.      CASE (WATER_LEVEL_TOKEN)
  1645.        if (!(Object->Type & WATER_LEVEL_OK_OBJECT))
  1646.          Error ("Cannot use WATER_LEVEL here");
  1647.        ((HEIGHT_FIELD *) Object)->bounding_box->bounds[0].y = 65536.0 * Parse_Float();
  1648.      END_CASE
  1649.  
  1650.      CASE (SMOOTH_TOKEN)
  1651.        if (!(Object->Type & SMOOTH_OK_OBJECT))
  1652.          Error ("Cannot use SMOOTH here");
  1653.        ((HEIGHT_FIELD *) Object)->Smoothed = TRUE;
  1654.      END_CASE
  1655.  
  1656.      CASE (NO_SHADOW_TOKEN)
  1657.        Object->No_Shadow_Flag = TRUE;
  1658.      END_CASE
  1659.  
  1660.      CASE (LIGHT_SOURCE_TOKEN)
  1661.        Error("Light source must be defined using new syntax");
  1662.      END_CASE
  1663.  
  1664.      OTHERWISE
  1665.        UNGET
  1666.        EXIT
  1667.      END_CASE
  1668.    END_EXPECT
  1669.  
  1670.    if (Object->Bound != NULL)
  1671.      {
  1672.       Object->Bounds.Lower_Left = Object->Bound->Bounds.Lower_Left;
  1673.       Object->Bounds.Lengths    = Object->Bound->Bounds.Lengths;
  1674.      }
  1675.    Parse_End ();
  1676.   }
  1677.  
  1678. static OBJECT *Parse_Sphere (void)
  1679.   {
  1680.    SPHERE *Object;
  1681.  
  1682.    Parse_Begin ();
  1683.  
  1684.    if ( (Object = (SPHERE *)Parse_Object_Id()) != NULL)
  1685.       return ((OBJECT *) Object);
  1686.       
  1687.    Object = Create_Sphere();
  1688.  
  1689.    Parse_Vector(&(Object -> Center));   Parse_Comma();
  1690.    Object -> Radius = Parse_Float();
  1691.    Object -> Radius_Squared = Object -> Radius * Object -> Radius;
  1692.    Object -> Inverse_Radius = 1.0 / Object -> Radius;
  1693.  
  1694.    Make_Vector(&Object->Bounds.Lower_Left,
  1695.            Object->Center.x - Object->Radius,
  1696.            Object->Center.y - Object->Radius,
  1697.            Object->Center.z - Object->Radius);
  1698.    Make_Vector(&Object->Bounds.Lengths,
  1699.            2.0 * Object->Radius,
  1700.            2.0 * Object->Radius,
  1701.            2.0 * Object->Radius);
  1702.  
  1703.    Parse_Object_Mods ((OBJECT *) Object);
  1704.  
  1705.    return ((OBJECT *) Object);
  1706.   }
  1707.  
  1708. static OBJECT *Parse_Plane (void)
  1709.   {
  1710.    PLANE *Object;
  1711.  
  1712.    Parse_Begin ();
  1713.  
  1714.    if ( (Object = (PLANE *)Parse_Object_Id()) != NULL)
  1715.       return ((OBJECT *) Object);
  1716.       
  1717.    Object = Create_Plane();
  1718.  
  1719.    Parse_Vector(&(Object -> Normal_Vector));   Parse_Comma();
  1720.    VNormalize(Object->Normal_Vector, Object->Normal_Vector);
  1721.    Object->Distance = -Parse_Float();
  1722.  
  1723.    Parse_Object_Mods ((OBJECT *)Object);
  1724.  
  1725.    return ((OBJECT *) Object);
  1726.   }
  1727.  
  1728. static OBJECT *Parse_Height_Field (void)
  1729.   {
  1730.    HEIGHT_FIELD *Object;
  1731.    VECTOR Local_Vector;
  1732.    IMAGE *Image;
  1733.  
  1734.    Parse_Begin ();
  1735.  
  1736.    if ( (Object = (HEIGHT_FIELD *)Parse_Object_Id()) != NULL)
  1737.       return ((OBJECT *) Object);
  1738.       
  1739.    Object = Create_Height_Field();
  1740.  
  1741.    Image = Parse_Image (HF_FILE);
  1742.    Image->Use_Colour_Flag = FALSE;
  1743.  
  1744.    Object->bounding_box->bounds[0].x = 1.0;
  1745.    Object->bounding_box->bounds[0].y = 0.0;
  1746.    Object->bounding_box->bounds[0].z = 1.0;
  1747.    if (Image->File_Type == POT_FILE)
  1748.      {
  1749.       Object->bounding_box->bounds[1].x = Image -> width/2.0 - 2.0;
  1750.       Make_Vector(&Local_Vector,2.0/Image->width,1.0/65536.0,1.0/Image->height);
  1751.      }
  1752.    else
  1753.      {
  1754.       Object->bounding_box->bounds[1].x = Image -> width - 2.0;
  1755.       Make_Vector(&Local_Vector,1.0/(Image->width),1.0/65536.0,1.0/(Image->height));
  1756.      }
  1757.    Object->bounding_box->bounds[1].y = 65536.0;
  1758.    Object->bounding_box->bounds[1].z = Image -> height - 2.0;
  1759.    Compute_Scaling_Transform(Object->Trans,&Local_Vector);
  1760.  
  1761.    Parse_Object_Mods ((OBJECT *)Object);
  1762.  
  1763.    Find_Hf_Min_Max(Object, Image);
  1764.  
  1765.    return ((OBJECT *) Object);
  1766.   }
  1767.  
  1768. static OBJECT *Parse_Triangle (void)
  1769.   {
  1770.    TRIANGLE *Object;
  1771.  
  1772.    Parse_Begin ();
  1773.  
  1774.    if ( (Object = (TRIANGLE *)Parse_Object_Id()) != NULL)
  1775.       return ((OBJECT *) Object);
  1776.       
  1777.    Object = Create_Triangle();
  1778.  
  1779.    Parse_Vector (&Object->P1);    Parse_Comma();
  1780.    Parse_Vector (&Object->P2);    Parse_Comma();
  1781.    Parse_Vector (&Object->P3);
  1782.    if (!Compute_Triangle (Object,FALSE))
  1783.      fprintf (stdout, "Degenerate triangle on line %d.  Please remove.\n",
  1784.               Token.Token_Line_No+1);
  1785.  
  1786.    Parse_Object_Mods ((OBJECT *)Object);
  1787.  
  1788.    return ((OBJECT *) Object);
  1789.   }
  1790.  
  1791. static OBJECT *Parse_Smooth_Triangle (void )
  1792.   {
  1793.    SMOOTH_TRIANGLE *Object;
  1794.    short degen;                                                   /* LSK */
  1795.    DBL vlen;                                                      /* LSK */
  1796.  
  1797.    degen=FALSE;
  1798.  
  1799.    Parse_Begin ();
  1800.  
  1801.    if ( (Object = (SMOOTH_TRIANGLE *)Parse_Object_Id()) != NULL)
  1802.       return ((OBJECT *) Object);
  1803.  
  1804.    Object = Create_Smooth_Triangle();
  1805.  
  1806.    Parse_Vector (&Object->P1);    Parse_Comma();
  1807.    Parse_Vector (&Object->N1);    Parse_Comma();
  1808.  
  1809.    VLength(vlen,Object->N1);                                     /* LSK */
  1810.    if (vlen<1E-09)                                               /* LSK */
  1811.      degen=TRUE;                                                 /* LSK */
  1812.    else                                                          /* LSK */
  1813.      VNormalize (Object->N1, Object->N1);
  1814.  
  1815.    Parse_Vector (&Object->P2);    Parse_Comma();
  1816.    Parse_Vector (&Object->N2);    Parse_Comma();
  1817.  
  1818.    VLength(vlen,Object->N2);                                     /* LSK */
  1819.    if (vlen<1E-09)                                               /* LSK */
  1820.      degen=TRUE;                                                 /* LSK */
  1821.    else                                                          /* LSK */
  1822.      VNormalize (Object->N2, Object->N2);
  1823.  
  1824.    Parse_Vector (&Object->P3);    Parse_Comma();
  1825.    Parse_Vector (&Object->N3);
  1826.  
  1827.    VLength(vlen,Object->N3);                                     /* LSK */
  1828.    if (vlen<1E-09)                                               /* LSK */
  1829.      degen=TRUE;                                                 /* LSK */
  1830.    else                                                          /* LSK */
  1831.      VNormalize (Object->N3, Object->N3);
  1832.  
  1833.    if (!degen) {                                                 /* LSK */
  1834.      degen=!Compute_Triangle ((TRIANGLE *) Object,TRUE);         /* LSK */
  1835.    }
  1836.  
  1837.    if (degen)                                                    /* LSK */
  1838.      fprintf (stdout, "Degenerate triangle on line %d.  Please remove.\n",
  1839.               Token.Token_Line_No+1);
  1840.  
  1841.    Parse_Object_Mods ((OBJECT *)Object);
  1842.  
  1843.    return ((OBJECT *) Object);
  1844.  }
  1845.  
  1846. static OBJECT *Parse_Quadric (void)
  1847.   {
  1848.    QUADRIC *Object;
  1849.  
  1850.    Parse_Begin ();
  1851.  
  1852.    if ( (Object = (QUADRIC *)Parse_Object_Id()) != NULL)
  1853.       return ((OBJECT *) Object);
  1854.       
  1855.    Object = Create_Quadric();
  1856.  
  1857.    Parse_Vector(&(Object -> Square_Terms));     Parse_Comma();
  1858.    Parse_Vector(&(Object -> Mixed_Terms));      Parse_Comma();
  1859.    Parse_Vector(&(Object -> Terms));            Parse_Comma();
  1860.    Object -> Constant = Parse_Float();
  1861.    Object -> Non_Zero_Square_Term =
  1862.      !( (Object -> Square_Terms.x == 0.0)
  1863.      && (Object -> Square_Terms.y == 0.0)
  1864.      && (Object -> Square_Terms.z == 0.0)
  1865.      && (Object -> Mixed_Terms.x == 0.0)
  1866.      && (Object -> Mixed_Terms.y == 0.0)
  1867.      && (Object -> Mixed_Terms.z == 0.0));
  1868.  
  1869.    Parse_Object_Mods ((OBJECT *)Object);
  1870.  
  1871.    return ((OBJECT *) Object);
  1872.   }
  1873.  
  1874. static OBJECT *Parse_Box (void)
  1875.   {
  1876.    BOX *Object;
  1877.  
  1878.    Parse_Begin ();
  1879.  
  1880.    if ( (Object = (BOX *)Parse_Object_Id()) != NULL)
  1881.       return ((OBJECT *) Object);
  1882.       
  1883.    Object = Create_Box();
  1884.  
  1885.    Parse_Vector(&(Object->bounds[0]));     Parse_Comma();
  1886.    Parse_Vector(&(Object->bounds[1]));
  1887.    
  1888.    Object->Bounds.Lower_Left=Object->bounds[0];
  1889.    VSub(Object->Bounds.Lengths, Object->bounds[1],Object->bounds[0]);
  1890.  
  1891.    Parse_Object_Mods ((OBJECT *)Object);
  1892.  
  1893.    return ((OBJECT *) Object);
  1894.   }
  1895.  
  1896. static OBJECT *Parse_Disc (void)
  1897.   {
  1898.    DISC *Object;
  1899.    DBL tmpf;
  1900.    VECTOR lengths;
  1901.  
  1902.    Parse_Begin ();
  1903.  
  1904.    if ( (Object = (DISC *)Parse_Object_Id()) != NULL)
  1905.       return ((OBJECT *) Object);
  1906.       
  1907.    Object = Create_Disc();
  1908.  
  1909.    Parse_Vector(&(Object->center)); Parse_Comma ();
  1910.    Parse_Vector(&(Object->normal)); Parse_Comma ();
  1911.    VNormalize(Object->normal, Object->normal);
  1912.  
  1913.    tmpf = Parse_Float(); Parse_Comma ();
  1914.    Object->oradius2 = tmpf * tmpf;
  1915.  
  1916.    EXPECT
  1917.      CASE_FLOAT
  1918.        tmpf = Parse_Float();
  1919.        Object->iradius2 = tmpf * tmpf;
  1920.      END_CASE
  1921.  
  1922.      OTHERWISE
  1923.        UNGET
  1924.        EXIT
  1925.      END_CASE
  1926.    END_EXPECT
  1927.  
  1928.    /* Calculate info needed for ray-disc intersections */
  1929.    VDot(tmpf, Object->center, Object->normal);
  1930.    Object->d = -tmpf;
  1931.  
  1932.    /* Calculate the bounds */
  1933.    tmpf = sqrt(Object->oradius2);
  1934.    Make_Vector(&lengths, tmpf, tmpf, tmpf);
  1935.    VSub(Object->Bounds.Lower_Left, Object->center, lengths);
  1936.    VScale(Object->Bounds.Lengths, lengths, 2.0);
  1937.  
  1938.    Parse_Object_Mods ((OBJECT *)Object);
  1939.  
  1940.    return ((OBJECT *) Object);
  1941.   }
  1942.  
  1943. static OBJECT *Parse_Cylinder (void)
  1944.   {
  1945.    CONE *Object;
  1946.  
  1947.    Parse_Begin ();
  1948.  
  1949.    if ( (Object = (CONE *)Parse_Object_Id()) != NULL)
  1950.       return ((OBJECT *) Object);
  1951.       
  1952.    Object = Create_Cylinder();
  1953.  
  1954.    Parse_Vector(&(Object->apex));  Parse_Comma ();
  1955.    Parse_Vector(&(Object->base));  Parse_Comma ();
  1956.    Object->apex_radius = Parse_Float();
  1957.    Object->base_radius = Object->apex_radius;
  1958.  
  1959.    EXPECT
  1960.      CASE(OPEN_TOKEN)
  1961.        Object->closed = 0;
  1962.        EXIT
  1963.      END_CASE
  1964.      
  1965.      OTHERWISE
  1966.        UNGET
  1967.        EXIT
  1968.      END_CASE
  1969.    END_EXPECT
  1970.  
  1971.    Compute_Cylinder_Data((OBJECT *)Object);
  1972.  
  1973.    Parse_Object_Mods ((OBJECT *)Object);
  1974.  
  1975.    return ((OBJECT *) Object);
  1976.   }
  1977.  
  1978. static OBJECT *Parse_Cone (void)
  1979.   {
  1980.    CONE *Object;
  1981.  
  1982.    Parse_Begin ();
  1983.  
  1984.    if ( (Object = (CONE *)Parse_Object_Id()) != NULL)
  1985.       return ((OBJECT *) Object);
  1986.       
  1987.    Object = Create_Cone();
  1988.  
  1989.    Parse_Vector(&(Object->apex));  Parse_Comma ();
  1990.    Object->apex_radius = Parse_Float();  Parse_Comma ();
  1991.  
  1992.    Parse_Vector(&(Object->base));  Parse_Comma ();
  1993.    Object->base_radius = Parse_Float();
  1994.    
  1995.    EXPECT
  1996.      CASE(OPEN_TOKEN)
  1997.        Object->closed = 0;
  1998.        EXIT
  1999.      END_CASE
  2000.      
  2001.      OTHERWISE
  2002.        UNGET
  2003.        EXIT
  2004.      END_CASE
  2005.    END_EXPECT
  2006.  
  2007.    /* Compute run-time values for the cone */
  2008.    Compute_Cone_Data((OBJECT *)Object);
  2009.  
  2010.    Parse_Object_Mods ((OBJECT *)Object);
  2011.  
  2012.    return ((OBJECT *) Object);
  2013.   }
  2014.  
  2015. static OBJECT *Parse_Blob (void)
  2016.   {
  2017.    BLOB *Object;
  2018.    DBL threshold;
  2019.    int npoints;
  2020.    blobstackptr blob_components, blob_component;
  2021.  
  2022.    Parse_Begin ();
  2023.  
  2024.    if ( (Object = (BLOB *)Parse_Object_Id()) != NULL)
  2025.       return ((OBJECT *) Object);
  2026.       
  2027.    Object = Create_Blob();
  2028.  
  2029.    blob_components = NULL;
  2030.    npoints = 0;
  2031.    threshold = 1.0;
  2032.  
  2033.    EXPECT
  2034.      CASE (THRESHOLD_TOKEN)
  2035.        threshold = Parse_Float();
  2036.      END_CASE
  2037.  
  2038.      CASE (COMPONENT_TOKEN)
  2039.        blob_component = (blobstackptr) malloc(sizeof(struct blob_list_struct));
  2040.        if (blob_component == NULL)
  2041.           MAError("blob component");
  2042.        blob_component->elem.coeffs[2] = Parse_Float(); Parse_Comma();
  2043.        blob_component->elem.radius2   = Parse_Float(); Parse_Comma();
  2044.        Parse_Vector(&blob_component->elem.pos);
  2045.        blob_component->next = blob_components;
  2046.        blob_components = blob_component;
  2047.        npoints++;
  2048.      END_CASE
  2049.  
  2050.      OTHERWISE
  2051.        UNGET
  2052.        EXIT
  2053.      END_CASE
  2054.    END_EXPECT
  2055.  
  2056.    /* Finally, process the information */
  2057.    MakeBlob(Object, threshold, blob_components, npoints, 0);
  2058.  
  2059.    Parse_Object_Mods ((OBJECT *)Object);
  2060.  
  2061.    return ((OBJECT *) Object);
  2062.   }
  2063.  
  2064. static OBJECT *Parse_Torus (void)
  2065.   {
  2066.    POLY *Object;
  2067.    DBL iradius, oradius, *Coeffs;
  2068.  
  2069.    Parse_Begin ();
  2070.  
  2071.    if ( (Object = (POLY *)Parse_Object_Id()) != NULL)
  2072.       return ((OBJECT *) Object);
  2073.       
  2074.    Object = Create_Poly(4);
  2075.  
  2076.    /* Read in the two radii */
  2077.    iradius = Parse_Float(); /* Big radius */
  2078.    Parse_Comma();
  2079.    oradius = Parse_Float(); /* Little radius */
  2080.  
  2081.    /* Build the coefficients of a torus lying in the x-z plane */
  2082.    Coeffs = Object->Coeffs;
  2083.    Coeffs[ 0] =  1.0;
  2084.    Coeffs[ 4] =  2.0;
  2085.    Coeffs[ 7] =  2.0;
  2086.    Coeffs[ 9] = -2.0 * (iradius * iradius + oradius * oradius);
  2087.    Coeffs[20] =  1.0;
  2088.    Coeffs[23] =  2.0;
  2089.    Coeffs[25] =  2.0 * (iradius * iradius - oradius * oradius);
  2090.    Coeffs[30] =  1.0;
  2091.    Coeffs[32] = -2.0 * (iradius * iradius + oradius * oradius);
  2092.    Coeffs[34] = (iradius * iradius - oradius * oradius) *
  2093.             (iradius * iradius - oradius * oradius);
  2094.  
  2095.    Make_Vector(&Object->Bounds.Lower_Left, -(iradius + oradius),
  2096.            -iradius, -(iradius + oradius))
  2097.    Make_Vector(&Object->Bounds.Lengths, 2.0 * (iradius + oradius),
  2098.            2.0 * iradius, 2.0 * (iradius + oradius));
  2099.  
  2100.    Parse_Object_Mods ((OBJECT *)Object);
  2101.  
  2102.    return ((OBJECT *) Object);
  2103.   }
  2104.  
  2105. static OBJECT *Parse_Poly (int order)
  2106. /*
  2107.   int order;
  2108. */
  2109.   {
  2110.    POLY *Object;
  2111.  
  2112.    Parse_Begin ();
  2113.  
  2114.    if ( (Object = (POLY *)Parse_Object_Id()) != NULL)
  2115.       return ((OBJECT *) Object);
  2116.       
  2117.    if (order == 0)
  2118.      {
  2119.       order = (int)Parse_Float();      Parse_Comma();
  2120.       if (order < 2 || order > MAX_ORDER)
  2121.         Error("Order of poly is out of range");
  2122.      }
  2123.  
  2124.    Object = Create_Poly(order);
  2125.  
  2126.    Parse_Coeffs(Object->Order, &(Object->Coeffs[0]));
  2127.  
  2128.    Parse_Object_Mods ((OBJECT *)Object);
  2129.  
  2130.    return ((OBJECT *) Object);
  2131.   }
  2132.  
  2133. static OBJECT *Parse_Bicubic_Patch (void)
  2134.   {
  2135.    BICUBIC_PATCH *Object;
  2136.    int i, j;
  2137.  
  2138.    Parse_Begin ();
  2139.  
  2140.    if ( (Object = (BICUBIC_PATCH *)Parse_Object_Id()) != NULL)
  2141.       return ((OBJECT *) Object);
  2142.       
  2143.    Object = Create_Bicubic_Patch();
  2144.  
  2145.    EXPECT
  2146.      CASE_FLOAT
  2147.        Warn("Should use keywords for bicubic parameters.",1.5);
  2148.        Object->Patch_Type = (int)Parse_Float();
  2149.        if (Object->Patch_Type == 2 ||
  2150.            Object->Patch_Type == 3)
  2151.            Object->Flatness_Value = Parse_Float();
  2152.          else
  2153.            Object->Flatness_Value = 0.1;
  2154.        Object->U_Steps = (int)Parse_Float();
  2155.        Object->V_Steps = (int)Parse_Float();
  2156.        EXIT
  2157.      END_CASE       
  2158.        
  2159.      CASE (TYPE_TOKEN)
  2160.        Object->Patch_Type = (int)Parse_Float();
  2161.      END_CASE
  2162.  
  2163.      CASE (FLATNESS_TOKEN)
  2164.        Object->Flatness_Value = Parse_Float();
  2165.      END_CASE
  2166.  
  2167.      CASE (V_STEPS_TOKEN)
  2168.        Object->V_Steps = (int)Parse_Float();
  2169.      END_CASE
  2170.  
  2171.      CASE (U_STEPS_TOKEN)
  2172.        Object->U_Steps = (int)Parse_Float();
  2173.      END_CASE
  2174.  
  2175.      OTHERWISE
  2176.        UNGET
  2177.        EXIT
  2178.      END_CASE
  2179.    END_EXPECT
  2180.  
  2181.    if (Object->Patch_Type > 1)
  2182.      {
  2183.       Object->Patch_Type = 1;
  2184.       Warn("Patch type no longer supported. Using type 1.",0.0);
  2185.      }
  2186.  
  2187.    if ((Object->Patch_Type < 0) || (Object->Patch_Type > MAX_PATCH_TYPE))
  2188.      Error("Undefined bicubic patch type");
  2189.  
  2190.    Parse_Comma();
  2191.    for (i=0;i<4;i++)
  2192.      for (j=0;j<4;j++)
  2193.        {
  2194.         Parse_Vector(&(Object -> Control_Points[i][j]));
  2195.         if (!((i==3)&&(j==3)))
  2196.           Parse_Comma();
  2197.        };
  2198.    Precompute_Patch_Values(Object); /* interpolated mesh coords */
  2199.  
  2200.    Parse_Object_Mods ((OBJECT *)Object);
  2201.  
  2202.    return ((OBJECT *) Object);
  2203.   }
  2204.  
  2205. static
  2206. OBJECT *Parse_CSG (CSG_Type)
  2207.   int CSG_Type;
  2208.   {
  2209.    CSG *Object;
  2210.    OBJECT *Local;
  2211.    int Object_Count = 0;
  2212.  
  2213.    Parse_Begin ();
  2214.  
  2215.    if ( (Object = (CSG *)Parse_Object_Id()) != NULL)
  2216.       return ((OBJECT *) Object);
  2217.       
  2218.    if (CSG_Type & CSG_UNION_TYPE)
  2219.      Object = Create_CSG_Union ();
  2220.    else
  2221.      if (CSG_Type & CSG_MERGE_TYPE)
  2222.        Object = Create_CSG_Merge ();
  2223.      else
  2224.        Object = Create_CSG_Intersection ();
  2225.  
  2226.    Object->Children = NULL;
  2227.  
  2228.    while ((Local = Parse_Object ()) != NULL)
  2229.      {
  2230.       if ((CSG_Type & CSG_INTERSECTION_TYPE) && (Local->Type & PATCH_OBJECT))
  2231.         Warn ("Patch objects not allowed in intersection",0.0);
  2232.       Object_Count++;
  2233.       if ((CSG_Type & CSG_DIFFERENCE_TYPE) && (Object_Count > 1))
  2234.         Invert_Object (Local);
  2235.       Object->Type |=  (Local->Type & CHILDREN_FLAGS);
  2236.       Local->Type |= IS_CHILD_OBJECT;
  2237.       Link(Local, &Local->Sibling, &Object->Children);
  2238.      };
  2239.  
  2240.    if ((Object_Count < 2) && (Language_Version >= 1.5))
  2241.      Warn ("Should have at least 2 objects in csg",1.5);
  2242.    Compute_CSG_Bounds((OBJECT *)Object);
  2243.  
  2244.    Parse_Object_Mods ((OBJECT *)Object);
  2245.  
  2246.    return ((OBJECT *) Object);
  2247.   }
  2248.  
  2249. static
  2250. OBJECT *Parse_Light_Source ()
  2251.   {
  2252.    VECTOR Local_Vector;
  2253.    LIGHT_SOURCE *Object;
  2254.  
  2255.    Parse_Begin ();
  2256.  
  2257.    if ( (Object = (LIGHT_SOURCE *)Parse_Object_Id()) != NULL)
  2258.       return ((OBJECT *) Object);
  2259.       
  2260.    Object = Create_Light_Source ();
  2261.  
  2262.    Parse_Vector(&Object->Center);
  2263.  
  2264.    GET (COLOUR_TOKEN)
  2265.  
  2266.    Parse_Colour (&Object->Colour);
  2267.  
  2268.    EXPECT
  2269.      CASE (LOOKS_LIKE_TOKEN)
  2270.        if (Object->Children != NULL)
  2271.          Error("Only one looks_like allowed per light_source");
  2272.        Parse_Begin ();
  2273.        Object->Type &= ~(int)PATCH_OBJECT;
  2274.        if ((Object->Children = Parse_Object ()) == NULL)
  2275.          Parse_Error_Str ("object");
  2276.        Translate_Object (Object->Children, &Object->Center);
  2277.        Parse_Object_Mods (Object->Children);
  2278.        Object->Children->No_Shadow_Flag = TRUE;
  2279.        Object->No_Shadow_Flag = TRUE;
  2280.        Object->Type |= (Object->Children->Type & CHILDREN_FLAGS);
  2281.      END_CASE
  2282.  
  2283.      CASE (SPOTLIGHT_TOKEN)
  2284.        Object->Light_Type = SPOT_SOURCE;
  2285.      END_CASE
  2286.  
  2287.      CASE (POINT_AT_TOKEN)
  2288.        if (Object->Light_Type == SPOT_SOURCE)
  2289.          Parse_Vector(&Object->Points_At);
  2290.        else
  2291.          Error("Spotlight param illegal in standard light source");
  2292.      END_CASE
  2293.  
  2294.      CASE (TIGHTNESS_TOKEN)
  2295.        if (Object->Light_Type == SPOT_SOURCE)
  2296.          Object->Coeff = Parse_Float();
  2297.        else
  2298.          Error("Spotlight param illegal in standard light source");
  2299.      END_CASE
  2300.  
  2301.      CASE (RADIUS_TOKEN)
  2302.        if (Object->Light_Type == SPOT_SOURCE)
  2303.          Object->Radius = cos(Parse_Float() * M_PI / 180.0);
  2304.        else
  2305.          Error("Spotlight param illegal in standard light source");
  2306.      END_CASE
  2307.  
  2308.      CASE (FALLOFF_TOKEN)
  2309.        if (Object->Light_Type == SPOT_SOURCE)
  2310.          Object->Falloff = cos(Parse_Float() * M_PI / 180.0);
  2311.        else
  2312.          Error("Spotlight param illegal in standard light source");
  2313.      END_CASE
  2314.  
  2315.      CASE (AREA_LIGHT_TOKEN)
  2316.        Object -> Area_Light = TRUE;
  2317.        Parse_Vector (&(Object -> Axis1)); Parse_Comma ();
  2318.        Parse_Vector (&(Object -> Axis2)); Parse_Comma ();
  2319.        Object -> Area_Size1 = (int)Parse_Float(); Parse_Comma ();
  2320.        Object -> Area_Size2 = (int)Parse_Float();
  2321.        Object -> Light_Grid = Create_Light_Grid (Object -> Area_Size1,
  2322.             Object -> Area_Size2);
  2323.      END_CASE
  2324.  
  2325.      CASE (JITTER_TOKEN)
  2326.        Object -> Jitter = TRUE;
  2327.      END_CASE
  2328.  
  2329.      CASE (TRACK_TOKEN)
  2330.        Object -> Track = TRUE;
  2331.      END_CASE
  2332.  
  2333.      CASE (ADAPTIVE_TOKEN)
  2334.        Object -> Adaptive_Level = (int)Parse_Float();
  2335.      END_CASE
  2336.  
  2337.      CASE (TRANSLATE_TOKEN)
  2338.        Parse_Vector (&Local_Vector);
  2339.        Translate_Object ((OBJECT *)Object, &Local_Vector);
  2340.      END_CASE
  2341.  
  2342.      CASE (ROTATE_TOKEN)
  2343.        Parse_Vector (&Local_Vector);
  2344.        Rotate_Object ((OBJECT *)Object, &Local_Vector);
  2345.      END_CASE
  2346.  
  2347.      CASE (SCALE_TOKEN)
  2348.        Parse_Scale_Vector (&Local_Vector);
  2349.        Scale_Object ((OBJECT *)Object, &Local_Vector);
  2350.      END_CASE
  2351.  
  2352.      CASE (TRANSFORM_TOKEN)
  2353.        GET(TRANSFORM_ID_TOKEN)
  2354.        Transform_Object ((OBJECT *)Object, (TRANSFORM *)Token.Constant_Data);
  2355.      END_CASE
  2356.  
  2357.      OTHERWISE
  2358.        UNGET
  2359.        EXIT
  2360.      END_CASE
  2361.    END_EXPECT
  2362.  
  2363.    Parse_End ();
  2364.  
  2365.    return ((OBJECT *)Object);
  2366.   }
  2367.  
  2368.  
  2369. static
  2370. OBJECT *Parse_Object ()
  2371.   {
  2372.    OBJECT *Object = NULL;
  2373.  
  2374.    EXPECT
  2375.      CASE (SPHERE_TOKEN)
  2376.        Object = Parse_Sphere ();
  2377.        EXIT
  2378.      END_CASE
  2379.  
  2380.      CASE (PLANE_TOKEN)
  2381.        Object = Parse_Plane ();
  2382.        EXIT
  2383.      END_CASE
  2384.  
  2385.      CASE (CONE_TOKEN)
  2386.        Object = Parse_Cone ();
  2387.        EXIT
  2388.      END_CASE
  2389.  
  2390.      CASE (CYLINDER_TOKEN)
  2391.        Object = Parse_Cylinder ();
  2392.        EXIT
  2393.      END_CASE
  2394.  
  2395.      CASE (DISC_TOKEN)
  2396.        Object = Parse_Disc ();
  2397.        EXIT
  2398.      END_CASE
  2399.  
  2400.      CASE (QUADRIC_TOKEN)
  2401.        Object = Parse_Quadric ();
  2402.        EXIT
  2403.      END_CASE
  2404.  
  2405.      CASE (CUBIC_TOKEN)
  2406.        Object = Parse_Poly (3);
  2407.        EXIT
  2408.      END_CASE
  2409.  
  2410.      CASE (QUARTIC_TOKEN)
  2411.        Object = Parse_Poly (4);
  2412.        EXIT
  2413.      END_CASE
  2414.  
  2415.      CASE (POLY_TOKEN)
  2416.        Object = Parse_Poly (0);
  2417.        EXIT
  2418.      END_CASE
  2419.  
  2420.      CASE (TORUS_TOKEN)
  2421.        Object = Parse_Torus ();
  2422.        EXIT
  2423.      END_CASE
  2424.  
  2425.      CASE (OBJECT_ID_TOKEN)
  2426.        Object = Copy_Object((OBJECT *) Token.Constant_Data);
  2427.        EXIT
  2428.      END_CASE
  2429.  
  2430.      CASE (UNION_TOKEN)
  2431.        Object = Parse_CSG (CSG_UNION_TYPE);
  2432.        EXIT
  2433.      END_CASE
  2434.  
  2435.      CASE (COMPOSITE_TOKEN)
  2436.        Warn("Use union instead of composite",1.5);
  2437.        Object = Parse_CSG (CSG_UNION_TYPE);
  2438.        EXIT
  2439.      END_CASE
  2440.  
  2441.      CASE (MERGE_TOKEN)
  2442.        Object = Parse_CSG (CSG_MERGE_TYPE);
  2443.        EXIT
  2444.      END_CASE
  2445.  
  2446.      CASE (INTERSECTION_TOKEN)
  2447.        Object = Parse_CSG (CSG_INTERSECTION_TYPE);
  2448.        EXIT
  2449.      END_CASE
  2450.  
  2451.      CASE (DIFFERENCE_TOKEN)
  2452.        Object = Parse_CSG (CSG_DIFFERENCE_TYPE+CSG_INTERSECTION_TYPE);
  2453.        EXIT
  2454.      END_CASE
  2455.  
  2456.      CASE (BICUBIC_PATCH_TOKEN)
  2457.        Object = Parse_Bicubic_Patch ();
  2458.        EXIT
  2459.      END_CASE
  2460.  
  2461.      CASE (TRIANGLE_TOKEN)
  2462.        Object = Parse_Triangle ();
  2463.        EXIT
  2464.      END_CASE
  2465.  
  2466.      CASE (SMOOTH_TRIANGLE_TOKEN)
  2467.        Object = Parse_Smooth_Triangle ();
  2468.        EXIT
  2469.      END_CASE
  2470.  
  2471.      CASE (HEIGHT_FIELD_TOKEN)
  2472.        Object = Parse_Height_Field ();
  2473.        EXIT
  2474.      END_CASE
  2475.  
  2476.      CASE (BOX_TOKEN)
  2477.        Object = Parse_Box ();
  2478.        EXIT
  2479.      END_CASE
  2480.  
  2481.      CASE (BLOB_TOKEN)
  2482.        Object = Parse_Blob ();
  2483.        EXIT
  2484.      END_CASE
  2485.  
  2486.      CASE (LIGHT_SOURCE_TOKEN)
  2487.        Object = Parse_Light_Source ();
  2488.        EXIT
  2489.      END_CASE
  2490.  
  2491.      CASE (OBJECT_TOKEN)
  2492.        Parse_Begin ();
  2493.        Object = Parse_Object ();
  2494.        if (!Object)
  2495.          Parse_Error_Str ("object");
  2496.        Parse_Object_Mods ((OBJECT *)Object);
  2497.        EXIT
  2498.      END_CASE
  2499.  
  2500.      OTHERWISE
  2501.        UNGET
  2502.        EXIT
  2503.      END_CASE
  2504.    END_EXPECT
  2505.  
  2506.    return ((OBJECT *) Object);
  2507.   }
  2508.  
  2509. static void Parse_Fog ()
  2510.   {
  2511.    Parse_Begin ();
  2512.  
  2513.    EXPECT
  2514.      CASE (COLOUR_TOKEN)
  2515.        Parse_Colour (&Frame.Fog_Colour);
  2516.      END_CASE
  2517.  
  2518.      CASE (DISTANCE_TOKEN)
  2519.        Frame.Fog_Distance = Parse_Float ();
  2520.      END_CASE
  2521.  
  2522.      CASE_FLOAT
  2523.        Warn("Should use distance keyword.",1.5);
  2524.        Frame.Fog_Distance = Parse_Float ();
  2525.      END_CASE
  2526.  
  2527.      OTHERWISE
  2528.        UNGET
  2529.        EXIT
  2530.      END_CASE
  2531.    END_EXPECT
  2532.    Parse_End ();
  2533.   }
  2534.  
  2535. static void Parse_Frame ()
  2536.   {
  2537.    OBJECT *Object;
  2538.    TEXTURE *Local_Texture;
  2539.    PIGMENT *Local_Pigment;
  2540.    TNORMAL *Local_Tnormal;
  2541.    FINISH  *Local_Finish;
  2542.  
  2543.    EXPECT
  2544.      CASE (FOG_TOKEN)
  2545.        Parse_Fog();
  2546.      END_CASE
  2547.  
  2548.      CASE (BACKGROUND_TOKEN)
  2549.        Parse_Begin();
  2550.        GET (COLOUR_TOKEN)
  2551.        Parse_Colour (&Frame.Background_Colour);
  2552.        Parse_End();
  2553.      END_CASE
  2554.  
  2555.      CASE (CAMERA_TOKEN)
  2556.        Parse_Camera (&Frame.Camera);
  2557.      END_CASE
  2558.  
  2559.      CASE (DECLARE_TOKEN)
  2560.        Parse_Declare ();
  2561.      END_CASE
  2562.  
  2563.      CASE (MAX_TRACE_LEVEL_TOKEN)
  2564.        Max_Trace_Level = Parse_Float ();
  2565.      END_CASE
  2566.  
  2567.      CASE (VERSION_TOKEN)
  2568.        Language_Version = Parse_Float ();
  2569.      END_CASE
  2570.  
  2571.      CASE (MAX_INTERSECTIONS)
  2572.        Max_Intersections = (int)Parse_Float ();
  2573.      END_CASE
  2574.  
  2575.      CASE (DEFAULT_TOKEN)
  2576.        Not_In_Default = FALSE;
  2577.        Parse_Begin();
  2578.        EXPECT
  2579.          CASE (TEXTURE_TOKEN)
  2580.            Local_Texture = Default_Texture;
  2581.            Default_Texture = Parse_Texture();
  2582.            if (Default_Texture->Type != PNF_TEXTURE)
  2583.              Error("Default texture cannot be material map or tiles");
  2584.            if (Default_Texture->Next_Layer != NULL)
  2585.              Error("Default texture cannot be layered");
  2586.            Destroy_Textures(Local_Texture);
  2587.          END_CASE
  2588.  
  2589.          CASE (PIGMENT_TOKEN)
  2590.            Local_Pigment = Copy_Pigment((Default_Texture->Pigment));
  2591.            Parse_Pigment (&Local_Pigment);
  2592.            Destroy_Pigment(Default_Texture->Pigment);
  2593.            Default_Texture->Pigment = Local_Pigment;
  2594.          END_CASE
  2595.  
  2596.          CASE (TNORMAL_TOKEN)
  2597.            Local_Tnormal = Copy_Tnormal((Default_Texture->Tnormal));
  2598.            Parse_Tnormal (&Local_Tnormal);
  2599.            Destroy_Tnormal(Default_Texture->Tnormal);
  2600.            Default_Texture->Tnormal = Local_Tnormal;
  2601.          END_CASE
  2602.  
  2603.          CASE (FINISH_TOKEN)
  2604.            Local_Finish = Copy_Finish((Default_Texture->Finish));
  2605.            Parse_Finish (&Local_Finish);
  2606.            Destroy_Finish(Default_Texture->Finish);
  2607.            Default_Texture->Finish = Local_Finish;
  2608.          END_CASE
  2609.  
  2610.          CASE (CAMERA_TOKEN)
  2611.            Parse_Camera (&Default_Camera);
  2612.          END_CASE
  2613.  
  2614.          OTHERWISE
  2615.            UNGET
  2616.            EXIT
  2617.          END_CASE
  2618.        END_EXPECT
  2619.        Parse_End();
  2620.        Not_In_Default = TRUE;
  2621.      END_CASE
  2622.  
  2623.      CASE (END_OF_FILE_TOKEN)
  2624.        EXIT
  2625.      END_CASE
  2626.  
  2627.      OTHERWISE
  2628.        UNGET
  2629.        Object = Parse_Object();
  2630.        if (Object == NULL)
  2631.          Parse_Error_Str ("object or directive");
  2632.        Post_Process (Object, NULL);
  2633.        Link_To_Frame (Object);
  2634.      END_CASE
  2635.    END_EXPECT
  2636.   }
  2637.  
  2638. static void Parse_Camera (Camera_Ptr)
  2639.   CAMERA **Camera_Ptr;
  2640.   {
  2641.    VECTOR Local_Vector, Temp_Vector;
  2642.    DBL Direction_Length, Up_Length, Right_Length, Handedness;
  2643.    CAMERA *New;
  2644.  
  2645.    Parse_Begin ();
  2646.  
  2647.    EXPECT
  2648.      CASE (CAMERA_ID_TOKEN)
  2649.        Destroy_Camera(*Camera_Ptr);
  2650.        *Camera_Ptr = Copy_Camera ((CAMERA *) Token.Constant_Data);
  2651.        EXIT
  2652.      END_CASE
  2653.  
  2654.      OTHERWISE
  2655.        UNGET
  2656.        EXIT
  2657.      END_CASE
  2658.    END_EXPECT
  2659.  
  2660.    New = *Camera_Ptr;
  2661.  
  2662.    EXPECT
  2663.      CASE (LOCATION_TOKEN)
  2664.        Parse_Vector(&(New->Location));
  2665.      END_CASE
  2666.  
  2667.      CASE (DIRECTION_TOKEN)
  2668.        Parse_Vector(&(New->Direction));
  2669.      END_CASE
  2670.  
  2671.      CASE (UP_TOKEN)
  2672.        Parse_Vector(&(New->Up));
  2673.      END_CASE
  2674.  
  2675.      CASE (RIGHT_TOKEN)
  2676.        Parse_Vector(&(New->Right));
  2677.      END_CASE
  2678.  
  2679.      CASE (SKY_TOKEN)
  2680.        Parse_Vector(&(New->Sky));
  2681.      END_CASE
  2682.  
  2683.      CASE (LOOK_AT_TOKEN)
  2684.        VLength (Direction_Length, New->Direction);
  2685.        VLength (Up_Length,        New->Up);
  2686.        VLength (Right_Length,     New->Right);
  2687.        VCross  (Temp_Vector,      New->Direction, New->Up);
  2688.        VDot    (Handedness,       Temp_Vector,   New->Right);
  2689.  
  2690.        Parse_Vector (&New->Direction);
  2691.  
  2692.        VSub       (New->Direction, New->Direction, New->Location);
  2693.        VNormalize (New->Direction, New->Direction);
  2694.        VCross     (New->Right,     New->Direction, New->Sky);
  2695.        VNormalize (New->Right,     New->Right);
  2696.        VCross     (New->Up,        New->Right,     New->Direction);
  2697.        VScale     (New->Direction, New->Direction, Direction_Length);
  2698.  
  2699.        if (Handedness >= 0.0)
  2700.          VScale (New->Right, New->Right, Right_Length)
  2701.        else
  2702.          VScale (New->Right, New->Right, -Right_Length);
  2703.  
  2704.        VScale (New->Up, New->Up, Up_Length);
  2705.      END_CASE
  2706.  
  2707.      CASE (TRANSLATE_TOKEN)
  2708.        Parse_Vector (&Local_Vector);
  2709.        Translate_Camera (New, &Local_Vector);
  2710.      END_CASE
  2711.  
  2712.      CASE (ROTATE_TOKEN)
  2713.        Parse_Vector (&Local_Vector);
  2714.        Rotate_Camera (New, &Local_Vector);
  2715.      END_CASE
  2716.  
  2717.      CASE (SCALE_TOKEN)
  2718.        Parse_Scale_Vector (&Local_Vector);
  2719.        Scale_Camera (New, &Local_Vector);
  2720.      END_CASE
  2721.  
  2722.      CASE (TRANSFORM_TOKEN)
  2723.        GET(TRANSFORM_ID_TOKEN)
  2724.        Transform_Camera (New, (TRANSFORM *)Token.Constant_Data);
  2725.      END_CASE
  2726.  
  2727.      OTHERWISE
  2728.        UNGET
  2729.        EXIT
  2730.      END_CASE
  2731.    END_EXPECT
  2732.    Parse_End ();
  2733.   }
  2734.  
  2735. static
  2736. TRANSFORM *Parse_Transform ()
  2737.   {
  2738.    TRANSFORM *New, Local_Trans;
  2739.    VECTOR Local_Vector;
  2740.  
  2741.    Parse_Begin ();
  2742.    New = Create_Transform ();
  2743.  
  2744.    EXPECT
  2745.      CASE(TRANSFORM_ID_TOKEN)
  2746.        Compose_Transforms (New, (TRANSFORM *)Token.Constant_Data);
  2747.        EXIT
  2748.      END_CASE
  2749.  
  2750.      CASE (TRANSLATE_TOKEN)
  2751.        Parse_Vector (&Local_Vector);
  2752.        Compute_Translation_Transform(&Local_Trans, &Local_Vector);
  2753.        Compose_Transforms (New, &Local_Trans);
  2754.      END_CASE
  2755.  
  2756.      CASE (ROTATE_TOKEN)
  2757.        Parse_Vector (&Local_Vector);
  2758.        Compute_Rotation_Transform(&Local_Trans, &Local_Vector);
  2759.        Compose_Transforms (New, &Local_Trans);
  2760.      END_CASE
  2761.  
  2762.      CASE (SCALE_TOKEN)
  2763.        Parse_Scale_Vector (&Local_Vector);
  2764.        Compute_Scaling_Transform(&Local_Trans, &Local_Vector);
  2765.        Compose_Transforms (New, &Local_Trans);
  2766.      END_CASE
  2767.  
  2768.      OTHERWISE
  2769.        UNGET
  2770.        EXIT
  2771.      END_CASE
  2772.    END_EXPECT
  2773.  
  2774.    Parse_End ();
  2775.    return (New);
  2776.   }
  2777.  
  2778. static void Parse_Declare ()
  2779.   {
  2780.   VECTOR Local_Vector;
  2781.   COLOUR *Local_Colour;
  2782.   PIGMENT *Local_Pigment;
  2783.   TNORMAL *Local_Tnormal;
  2784.   FINISH *Local_Finish;
  2785.   TEXTURE *Local_Texture;
  2786.   COLOUR_MAP *Local_Colour_Map;
  2787.   TRANSFORM *Local_Trans;
  2788.   OBJECT *Local_Object;
  2789.   CAMERA *Local_Camera;
  2790.  
  2791.   struct Constant_Struct *Constant_Ptr;
  2792.  
  2793.   EXPECT
  2794.     CASE (IDENTIFIER_TOKEN)
  2795.       if (++Number_Of_Constants >= MAX_CONSTANTS)
  2796.         Error ("Too many constants \"DECLARED\"");
  2797.       else
  2798.         Constant_Ptr = &(Constants[Number_Of_Constants]);
  2799.       EXIT
  2800.     END_CASE
  2801.  
  2802.     CASE4 (COLOUR_ID_TOKEN, VECTOR_ID_TOKEN, FLOAT_ID_TOKEN, PIGMENT_ID_TOKEN)
  2803.     CASE4 (TNORMAL_ID_TOKEN, FINISH_ID_TOKEN, TEXTURE_ID_TOKEN, OBJECT_ID_TOKEN)
  2804.     CASE3 (COLOUR_MAP_ID_TOKEN, TRANSFORM_ID_TOKEN, CAMERA_ID_TOKEN)
  2805.       Constant_Ptr = &(Constants[Token.Constant_Index]);
  2806.       EXIT
  2807.     END_CASE
  2808.  
  2809.     OTHERWISE
  2810.       Parse_Error(IDENTIFIER_TOKEN);
  2811.     END_CASE
  2812.   END_EXPECT
  2813.  
  2814.   Previous = Token.Token_Id;
  2815.  
  2816.   GET (EQUALS_TOKEN);
  2817.  
  2818.   EXPECT
  2819.     CASE (COLOUR_TOKEN)
  2820.       if (Test_Redefine(COLOUR_ID_TOKEN))
  2821.         Destroy_Colour((COLOUR *)Constant_Ptr->Constant_Data);
  2822.       Local_Colour = Create_Colour();
  2823.       Parse_Colour (Local_Colour);
  2824.       Constant_Ptr -> Constant_Data = (char *) Local_Colour;
  2825.       Constant_Ptr -> Constant_Type = COLOUR_CONSTANT;
  2826.       EXIT
  2827.     END_CASE
  2828.  
  2829.     CASE_VECTOR
  2830.       Have_Vector = FALSE;
  2831.       Parse_Vector_Float (&Local_Vector);
  2832.       if (Have_Vector)
  2833.         {
  2834.          if (Test_Redefine(VECTOR_ID_TOKEN))
  2835.            Destroy_Vector((VECTOR *)Constant_Ptr->Constant_Data);
  2836.          Constant_Ptr -> Constant_Type = VECTOR_CONSTANT;
  2837.          Constant_Ptr -> Constant_Data = (char *) Create_Vector();
  2838.          *((VECTOR *)Constant_Ptr -> Constant_Data) = Local_Vector;
  2839.         }
  2840.       else
  2841.         {
  2842.          if (Test_Redefine(FLOAT_ID_TOKEN))
  2843.            Destroy_Float((DBL *)Constant_Ptr->Constant_Data);
  2844.          Constant_Ptr -> Constant_Type = FLOAT_CONSTANT;
  2845.          Constant_Ptr -> Constant_Data = (char *) Create_Float();
  2846.          *((DBL *) Constant_Ptr -> Constant_Data) = Local_Vector.x;
  2847.         }
  2848.       EXIT
  2849.     END_CASE
  2850.  
  2851.     CASE (PIGMENT_TOKEN)
  2852.       if (Test_Redefine(PIGMENT_ID_TOKEN))
  2853.         Destroy_Pigment((PIGMENT *)Constant_Ptr->Constant_Data);
  2854.       Local_Pigment = Copy_Pigment((Default_Texture->Pigment));
  2855.       Parse_Pigment (&Local_Pigment);
  2856.       Constant_Ptr -> Constant_Type = PIGMENT_CONSTANT;
  2857.       Constant_Ptr -> Constant_Data = (char *)Local_Pigment;
  2858.       EXIT
  2859.     END_CASE
  2860.  
  2861.     CASE (TNORMAL_TOKEN)
  2862.       if (Test_Redefine(TNORMAL_ID_TOKEN))
  2863.         Destroy_Tnormal((TNORMAL *)Constant_Ptr->Constant_Data);
  2864.       Local_Tnormal = Copy_Tnormal((Default_Texture->Tnormal));
  2865.       Parse_Tnormal (&Local_Tnormal);
  2866.       Constant_Ptr -> Constant_Type = TNORMAL_CONSTANT;
  2867.       Constant_Ptr -> Constant_Data = (char *) Local_Tnormal;
  2868.       EXIT
  2869.     END_CASE
  2870.  
  2871.     CASE (FINISH_TOKEN)
  2872.       if (Test_Redefine(FINISH_ID_TOKEN))
  2873.         Destroy_Finish((FINISH *)Constant_Ptr->Constant_Data);
  2874.       Local_Finish = Copy_Finish((Default_Texture->Finish));
  2875.       Parse_Finish (&Local_Finish);
  2876.       Constant_Ptr -> Constant_Type = FINISH_CONSTANT;
  2877.       Constant_Ptr -> Constant_Data = (char *) Local_Finish;
  2878.       EXIT
  2879.     END_CASE
  2880.  
  2881.     CASE (CAMERA_TOKEN)
  2882.       if (Test_Redefine(CAMERA_ID_TOKEN))
  2883.         Destroy_Camera((CAMERA *)Constant_Ptr->Constant_Data);
  2884.       Local_Camera = Copy_Camera(Default_Camera);
  2885.       Parse_Camera (&Local_Camera);
  2886.       Constant_Ptr -> Constant_Type = CAMERA_CONSTANT;
  2887.       Constant_Ptr -> Constant_Data = (char *) Local_Camera;
  2888.       EXIT
  2889.     END_CASE
  2890.  
  2891.     CASE (TEXTURE_TOKEN)
  2892.       if (Test_Redefine(TEXTURE_ID_TOKEN))
  2893.         Destroy_Textures((TEXTURE *)Constant_Ptr->Constant_Data);
  2894.       Local_Texture = Parse_Texture ();
  2895.       Constant_Ptr -> Constant_Type = TEXTURE_CONSTANT;
  2896.       Constant_Ptr -> Constant_Data = NULL;
  2897.       Link_Textures((TEXTURE **) &Constant_Ptr->Constant_Data, Local_Texture);
  2898.       EXPECT
  2899.         CASE (TEXTURE_TOKEN)
  2900.           Local_Texture = Parse_Texture ();
  2901.           Link_Textures((TEXTURE **) &Constant_Ptr->Constant_Data, Local_Texture);
  2902.         END_CASE
  2903.  
  2904.         OTHERWISE
  2905.           UNGET
  2906.           EXIT
  2907.         END_CASE
  2908.       END_EXPECT
  2909.       EXIT
  2910.     END_CASE
  2911.  
  2912.     CASE (COLOUR_MAP_TOKEN)
  2913.       if (Test_Redefine(COLOUR_MAP_ID_TOKEN))
  2914.         Destroy_Colour_Map((COLOUR_MAP *)Constant_Ptr->Constant_Data);
  2915.       Local_Colour_Map = Parse_Colour_Map ();
  2916.       Constant_Ptr -> Constant_Type = COLOUR_MAP_CONSTANT;
  2917.       Constant_Ptr -> Constant_Data = (char *) Local_Colour_Map;
  2918.       EXIT
  2919.     END_CASE
  2920.  
  2921.     CASE (TRANSFORM_TOKEN)
  2922.       if (Test_Redefine(TRANSFORM_ID_TOKEN))
  2923.         Destroy_Transform((TRANSFORM *)Constant_Ptr->Constant_Data);
  2924.       Local_Trans = Parse_Transform ();
  2925.       Constant_Ptr -> Constant_Type = TRANSFORM_CONSTANT;
  2926.       Constant_Ptr -> Constant_Data = (char *) Local_Trans;
  2927.       EXIT
  2928.     END_CASE
  2929.  
  2930.     OTHERWISE
  2931.       UNGET
  2932.       if (Test_Redefine(OBJECT_ID_TOKEN))
  2933.         Destroy_Object((OBJECT *)Constant_Ptr->Constant_Data);
  2934.       Local_Object = Parse_Object ();
  2935.       Constant_Ptr -> Constant_Type = OBJECT_CONSTANT;
  2936.       Constant_Ptr -> Constant_Data = (char *) Local_Object;
  2937.       EXIT
  2938.     END_CASE
  2939.  
  2940.   END_EXPECT
  2941.   }
  2942.  
  2943. static void Link (New_Object, Field, Old_Object_List)
  2944.   OBJECT *New_Object, **Field, **Old_Object_List;
  2945.   {
  2946.   *Field = *Old_Object_List;
  2947.   *Old_Object_List = New_Object;
  2948.   }
  2949.  
  2950. static void Link_Textures (Old_Textures, New_Textures)
  2951.   TEXTURE **Old_Textures;
  2952.   TEXTURE  *New_Textures;
  2953.   {
  2954.    TEXTURE *Layer;
  2955.  
  2956.    for (Layer = New_Textures ;
  2957.         Layer->Next_Layer != NULL ;
  2958.         Layer = Layer->Next_Layer)
  2959.      {}
  2960.         Layer->Next_Layer = *Old_Textures;
  2961.         *Old_Textures = New_Textures;
  2962.   }
  2963.  
  2964. static
  2965. char *Get_Token_String (Token_Id)
  2966.   TOKEN Token_Id;
  2967.   {
  2968.   register int i;
  2969.  
  2970.   for (i = 0 ; i < LAST_TOKEN ; i++)
  2971.      if (Reserved_Words[i].Token_Number == Token_Id)
  2972.         return (Reserved_Words[i].Token_Name);
  2973.   return ("");
  2974.   }
  2975.  
  2976. static
  2977. void Where_Error ()
  2978.   {
  2979.   fprintf (stderr, "\nError in file %s line %d\n", Token.Filename,
  2980.                                                  Token.Token_Line_No+1);
  2981.   }
  2982.  
  2983. static int Test_Redefine(a)
  2984.   int a;
  2985.   {
  2986.   char *old, *new;
  2987.  
  2988.   if (Previous == IDENTIFIER_TOKEN)
  2989.     return (FALSE);
  2990.   if (Previous != a)
  2991.     {old = Get_Token_String (Previous);
  2992.      new = Get_Token_String (a);
  2993.      Where_Error ();
  2994.      fprintf (stderr, "Attempted to redefine %s as %s", old, new);
  2995.      exit (1);
  2996.     }
  2997.   return (TRUE);
  2998.   }
  2999.  
  3000. void Parse_Error (Token_Id)
  3001.   TOKEN Token_Id;
  3002.   {
  3003.   char *expected;
  3004.  
  3005.   expected = Get_Token_String (Token_Id);
  3006.   Parse_Error_Str(expected);
  3007.   }
  3008.  
  3009. void Parse_Error_Str (str)
  3010.   char *str;
  3011.   {
  3012.    Where_Error ();
  3013.    fprintf (stderr, "%s expected but", str);
  3014.    Found_Instead ();
  3015.    exit (1);
  3016.   }
  3017.  
  3018. static void Found_Instead ()
  3019.   {
  3020.   char *found;
  3021.  
  3022.   if (Token.Token_Id == IDENTIFIER_TOKEN)
  3023.     fprintf (stderr,
  3024.       " undeclared identifier '%s' found instead.\n", Token.Token_String);
  3025.   else
  3026.    {
  3027.     found = Get_Token_String (Token.Token_Id);
  3028.     fprintf (stderr, " %s found instead.\n", found);
  3029.    }
  3030.   }
  3031. /*
  3032. static void Parse_Warn (Token_Id)
  3033.   TOKEN Token_Id;
  3034.   {
  3035.   char *expected;
  3036.  
  3037.   fprintf (stderr, "\nWarning in file %s line %d\n", Token.Filename,
  3038.                                                    Token.Token_Line_No+1);
  3039.   expected = Get_Token_String (Token_Id);
  3040.   fprintf (stderr, "%s expected but", expected);
  3041.   Found_Instead ();
  3042.   }
  3043. */
  3044. static void Warn_State (Token_Id,Type)
  3045.   TOKEN Token_Id, Type;
  3046.   {
  3047.   char *found;
  3048.   char *should;
  3049.  
  3050.   if (Language_Version < 1.5)
  3051.      return;
  3052.  
  3053.   fprintf (stderr, "\nWarning in file %s line %d\n", Token.Filename,
  3054.                                                    Token.Token_Line_No+1);
  3055.   found = Get_Token_String (Token_Id);
  3056.   should = Get_Token_String (Type);
  3057.   fprintf (stderr, "Found %s that should be in %s statement", found, should);
  3058.   }
  3059.  
  3060. void Warn (str,Level)
  3061.   char *str;
  3062.   DBL Level;
  3063.   {
  3064.   if (Language_Version < Level)
  3065.     return;
  3066.     
  3067.   fprintf (stdout, "\nWarning in file %s line %d\n", Token.Filename,
  3068.                                                    Token.Token_Line_No+1);
  3069.   fputs (str, stdout);
  3070.   }
  3071.  
  3072. void Error (str)
  3073.   char *str;
  3074.   {
  3075.   Where_Error ();
  3076.   fputs (str, stderr);
  3077.   exit (1);
  3078.   }
  3079.  
  3080. void MAError (str)
  3081.   char *str;
  3082.   {
  3083.   Where_Error ();
  3084.   fprintf (stderr, "Out of memory.  Cannot allocate %s.\n",str);
  3085.   exit (1);
  3086.   }
  3087.  
  3088. /* Write a token out to the token file */
  3089.  
  3090. void Write_Token (Token_Id, Data_File)
  3091.   TOKEN Token_Id;
  3092.   DATA_FILE *Data_File;
  3093.  
  3094.   {
  3095.    Token.Token_Id = Token_Id;
  3096.    Token.Token_Line_No = Data_File->Line_Number;
  3097.    Token.Filename = Data_File->Filename;
  3098.    Token.Token_String = String;
  3099.    Token.Constant_Data = NULL;
  3100.    Token.Constant_Index = (int) Token.Token_Id - (int) LAST_TOKEN;
  3101.  
  3102.    if (Token.Constant_Index >= 0)
  3103.      {if (Token.Constant_Index <= Number_Of_Constants)
  3104.         {Token.Constant_Data = Constants[Token.Constant_Index].Constant_Data;
  3105.          switch (Constants[Token.Constant_Index].Constant_Type)
  3106.            {CASEID(COLOUR_CONSTANT,     COLOUR_ID_TOKEN)
  3107.             CASEID(VECTOR_CONSTANT,     VECTOR_ID_TOKEN)
  3108.             CASEID(FLOAT_CONSTANT,      FLOAT_ID_TOKEN)
  3109.             CASEID(PIGMENT_CONSTANT,    PIGMENT_ID_TOKEN)
  3110.             CASEID(TNORMAL_CONSTANT,    TNORMAL_ID_TOKEN)
  3111.             CASEID(FINISH_CONSTANT,     FINISH_ID_TOKEN)
  3112.             CASEID(TEXTURE_CONSTANT,    TEXTURE_ID_TOKEN)
  3113.             CASEID(OBJECT_CONSTANT,     OBJECT_ID_TOKEN)
  3114.             CASEID(COLOUR_MAP_CONSTANT, COLOUR_MAP_ID_TOKEN)
  3115.             CASEID(TRANSFORM_CONSTANT,  TRANSFORM_ID_TOKEN)
  3116.             CASEID(CAMERA_CONSTANT,     CAMERA_ID_TOKEN)
  3117.            }
  3118.         }
  3119.       else Token.Token_Id = IDENTIFIER_TOKEN;
  3120.      }
  3121.   }
  3122.  
  3123. static void Post_Process (Object,Parent)
  3124.   OBJECT *Object, *Parent;
  3125.   {
  3126.    OBJECT *Sib;
  3127.  
  3128.    if (Object == NULL)
  3129.      return;
  3130.  
  3131.    if (Parent != NULL)
  3132.      {
  3133.       if (Object->Texture == NULL)
  3134.         Object->Texture = Parent->Texture;
  3135. /*
  3136.       else
  3137.         if (Parent->Texture != NULL)
  3138.           {Local_Texture = Copy_Textures (Parent->Texture);
  3139.            Link_Textures (&(Object->Texture), Local_Texture);
  3140.           }
  3141. */ /* Removed for backward compat with 1.0.  May put back in. CEY 12/92 */
  3142.       Object->No_Shadow_Flag |= Parent->No_Shadow_Flag;
  3143.      }
  3144.      
  3145.    if (     (Object->Texture == NULL) 
  3146.         && !(Object->Type & TEXTURED_OBJECT) 
  3147.         && !(Object->Type & LIGHT_SOURCE_OBJECT))
  3148.      Object->Texture = Copy_Textures(Default_Texture);
  3149.  
  3150.    if (Object->Type & COMPOUND_OBJECT)
  3151.      {
  3152.       if (Object->Type & LIGHT_SOURCE_OBJECT)
  3153.         {
  3154.          ((LIGHT_SOURCE *)Object)->Next_Light_Source = Frame.Light_Sources;
  3155.          Frame.Light_Sources = (LIGHT_SOURCE *)Object;
  3156.         }
  3157.       for (Sib = ((CSG *)Object)->Children;
  3158.            Sib != NULL;
  3159.            Sib = Sib->Sibling)
  3160.         Post_Process(Sib, Object);
  3161.      }
  3162.    else
  3163.      if (Object->Texture == NULL)
  3164.        Object->Texture = Copy_Textures(Default_Texture);
  3165.    Post_Textures (Object->Texture);
  3166.    if ((Object->Type & WATER_LEVEL_OK_OBJECT) &&
  3167.        (Object->Type & IS_CHILD_OBJECT))
  3168.      Object->Methods = &Csg_Height_Field_Methods;
  3169.   }
  3170.  
  3171. static void Destroy_Constants ()
  3172.   {
  3173.    int i;
  3174.    char *Ptr;
  3175.  
  3176.    for (i=1; i <= Number_Of_Constants; i++)
  3177.      {
  3178.       Ptr = Constants[i].Constant_Data;
  3179.       switch (Constants[i].Constant_Type)
  3180.         {
  3181.          case COLOUR_CONSTANT:
  3182.            Destroy_Colour((COLOUR *)Ptr);
  3183.            break;
  3184.          case VECTOR_CONSTANT:
  3185.            Destroy_Vector((VECTOR *)Ptr);
  3186.            break;
  3187.          case FLOAT_CONSTANT:
  3188.            Destroy_Float((DBL *)Ptr);
  3189.            break;
  3190.          case PIGMENT_CONSTANT:
  3191.            Destroy_Pigment((PIGMENT *)Ptr);
  3192.            break;
  3193.          case TNORMAL_CONSTANT:
  3194.            Destroy_Tnormal((TNORMAL *)Ptr);
  3195.            break;
  3196.          case FINISH_CONSTANT:
  3197.            Destroy_Finish((FINISH *)Ptr);
  3198.            break;
  3199.          case TEXTURE_CONSTANT:
  3200.            Destroy_Textures((TEXTURE *)Ptr);
  3201.            break;
  3202.          case OBJECT_CONSTANT:
  3203.            Destroy_Object((OBJECT *)Ptr);
  3204.            break;
  3205.          case COLOUR_MAP_CONSTANT:
  3206.            Destroy_Colour_Map((COLOUR_MAP *)Ptr);
  3207.            break;
  3208.          case TRANSFORM_CONSTANT:
  3209.            Destroy_Transform((TRANSFORM *)Ptr);
  3210.            break;
  3211.          case CAMERA_CONSTANT:
  3212.            Destroy_Camera((CAMERA *)Ptr);
  3213.            break;
  3214.         }
  3215.      }
  3216.   }
  3217.  
  3218. static void Link_To_Frame (Object)
  3219.  OBJECT *Object;
  3220.  {
  3221.   OBJECT *This_Sib, *Next_Sib;
  3222.   
  3223.   if ((Object->Methods != &CSG_Union_Methods) ||
  3224.       (Object->Bound != NULL) ||
  3225.       (Object->Clip != NULL) ||
  3226.       (!Use_Slabs))
  3227.     {
  3228.      Link(Object, &(Object -> Sibling), &(Frame.Objects));
  3229.      return;
  3230.     }
  3231.   
  3232.   for (This_Sib = ((CSG *)Object)->Children;
  3233.        This_Sib != NULL;
  3234.        This_Sib = Next_Sib)
  3235.        {
  3236.         Next_Sib = This_Sib->Sibling; /*L2F changes Sibling so save it */
  3237.         Link_To_Frame (This_Sib);
  3238.        }
  3239.   Object->Texture = NULL;
  3240.   Object->Sibling = NULL;
  3241.   ((CSG *)Object)->Children = NULL;
  3242.   Destroy_Object (Object);
  3243.  }
  3244.